%------------------------------------------------------------------------------
% File     : HWV104+1 : TPTP v9.0.0. Released v6.1.0.
% Domain   : Hardware Verification
% Problem  : dmu_dmc property 15 cone of influence 7_b20
% Version  : Especial.
% English  : Verification of a property of the SPARCT2 RTL hardware design.

% Refs     : [Kha14] Khasidashvili (2014), Email to Geoff Sutcliffe
% Source   : [Kha14]
% Names    : dmu_dmc_prop15_cone7_b20 [Kha14]

% Status   : Theorem
% Rating   : 1.00 v6.1.0
% Syntax   : Number of formulae    : 12115 (3224 unt;   0 def)
%            Number of atoms       : 42855 ( 969 equ)
%            Maximal formula atoms :  142 (   3 avg)
%            Number of connectives : 35301 (4561   ~;1640   |;7913   &)
%                                         (15693 <=>;5494  =>;   0  <=;   0 <~>)
%            Maximal formula depth :   75 (   4 avg)
%            Maximal term depth    :    1 (   1 avg)
%            Number of predicates  : 6535 (6532 usr;   2 prp; 0-3 aty)
%            Number of functors    : 1708 (1708 usr;1708 con; 0-0 aty)
%            Number of variables   : 12180 (12180   !;   0   ?)
% SPC      : FOF_THM_RFO_SEQ

% Comments : Copyright 2013 Moshe Emmer and Zurab Khasidashvili
%            Licensed under the Apache License, Version 2.0 (the "License");
%            you may not use this file except in compliance with the License.
%            You may obtain a copy of the License at
%                http://www.apache.org/licenses/LICENSE-2.0
%            Unless required by applicable law or agreed to in writing,
%            software distributed under the License is distributed on an "AS
%            IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
%            express or implied. See the License for the specific language
%            governing permissions and limitations under the License.
%------------------------------------------------------------------------------
fof(pathAxiom_8,axiom,
    nextState(constB8,constB9) ).

fof(pathAxiom_7,axiom,
    nextState(constB7,constB8) ).

fof(pathAxiom_6,axiom,
    nextState(constB6,constB7) ).

fof(pathAxiom_5,axiom,
    nextState(constB5,constB6) ).

fof(pathAxiom_4,axiom,
    nextState(constB4,constB5) ).

fof(pathAxiom_3,axiom,
    nextState(constB3,constB4) ).

fof(pathAxiom_2,axiom,
    nextState(constB2,constB3) ).

fof(pathAxiom_1,axiom,
    nextState(constB1,constB2) ).

fof(pathAxiom,axiom,
    nextState(constB0,constB1) ).

fof(reachableStateAxiom_22,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( reachableState(VarCurr)
        & reachableState(VarNext) ) ) ).

fof(reachableStateAxiom_21,axiom,
    ! [VarState] :
      ( reachableState(VarState)
     => ( constB0 = VarState
        | constB1 = VarState
        | constB2 = VarState
        | constB3 = VarState
        | constB4 = VarState
        | constB5 = VarState
        | constB6 = VarState
        | constB7 = VarState
        | constB8 = VarState
        | constB9 = VarState
        | constB10 = VarState
        | constB11 = VarState
        | constB12 = VarState
        | constB13 = VarState
        | constB14 = VarState
        | constB15 = VarState
        | constB16 = VarState
        | constB17 = VarState
        | constB18 = VarState
        | constB19 = VarState
        | constB20 = VarState ) ) ).

fof(reachableStateAxiom_20,axiom,
    reachableState(constB20) ).

fof(reachableStateAxiom_19,axiom,
    reachableState(constB19) ).

fof(reachableStateAxiom_18,axiom,
    reachableState(constB18) ).

fof(reachableStateAxiom_17,axiom,
    reachableState(constB17) ).

fof(reachableStateAxiom_16,axiom,
    reachableState(constB16) ).

fof(reachableStateAxiom_15,axiom,
    reachableState(constB15) ).

fof(reachableStateAxiom_14,axiom,
    reachableState(constB14) ).

fof(reachableStateAxiom_13,axiom,
    reachableState(constB13) ).

fof(reachableStateAxiom_12,axiom,
    reachableState(constB12) ).

fof(reachableStateAxiom_11,axiom,
    reachableState(constB11) ).

fof(reachableStateAxiom_10,axiom,
    reachableState(constB10) ).

fof(reachableStateAxiom_9,axiom,
    reachableState(constB9) ).

fof(reachableStateAxiom_8,axiom,
    reachableState(constB8) ).

fof(reachableStateAxiom_7,axiom,
    reachableState(constB7) ).

fof(reachableStateAxiom_6,axiom,
    reachableState(constB6) ).

fof(reachableStateAxiom_5,axiom,
    reachableState(constB5) ).

fof(reachableStateAxiom_4,axiom,
    reachableState(constB4) ).

fof(reachableStateAxiom_3,axiom,
    reachableState(constB3) ).

fof(reachableStateAxiom_2,axiom,
    reachableState(constB2) ).

fof(reachableStateAxiom_1,axiom,
    reachableState(constB1) ).

fof(reachableStateAxiom,axiom,
    reachableState(constB0) ).

fof(clock_toggling,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1(VarCurr)
      <=> ~ v1(VarNext) ) ) ).

fof(clock_pattern,axiom,
    ~ v1(constB0) ).

fof(transient_address_definition_230,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_20,B)
    <=> v7750(constB20,B) ) ).

fof(is_address_278,axiom,
    address(v7750_range_4_to_0_address_term_bound_20) ).

fof(address_association_230,axiom,
    v7750_range_4_to_0_address_association(constB20,v7750_range_4_to_0_address_term_bound_20) ).

fof(transient_address_definition_229,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_19,B)
    <=> v7750(constB19,B) ) ).

fof(is_address_277,axiom,
    address(v7750_range_4_to_0_address_term_bound_19) ).

fof(address_association_229,axiom,
    v7750_range_4_to_0_address_association(constB19,v7750_range_4_to_0_address_term_bound_19) ).

fof(transient_address_definition_228,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_18,B)
    <=> v7750(constB18,B) ) ).

fof(is_address_276,axiom,
    address(v7750_range_4_to_0_address_term_bound_18) ).

fof(address_association_228,axiom,
    v7750_range_4_to_0_address_association(constB18,v7750_range_4_to_0_address_term_bound_18) ).

fof(transient_address_definition_227,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_17,B)
    <=> v7750(constB17,B) ) ).

fof(is_address_275,axiom,
    address(v7750_range_4_to_0_address_term_bound_17) ).

fof(address_association_227,axiom,
    v7750_range_4_to_0_address_association(constB17,v7750_range_4_to_0_address_term_bound_17) ).

fof(transient_address_definition_226,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_16,B)
    <=> v7750(constB16,B) ) ).

fof(is_address_274,axiom,
    address(v7750_range_4_to_0_address_term_bound_16) ).

fof(address_association_226,axiom,
    v7750_range_4_to_0_address_association(constB16,v7750_range_4_to_0_address_term_bound_16) ).

fof(transient_address_definition_225,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_15,B)
    <=> v7750(constB15,B) ) ).

fof(is_address_273,axiom,
    address(v7750_range_4_to_0_address_term_bound_15) ).

fof(address_association_225,axiom,
    v7750_range_4_to_0_address_association(constB15,v7750_range_4_to_0_address_term_bound_15) ).

fof(transient_address_definition_224,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_14,B)
    <=> v7750(constB14,B) ) ).

fof(is_address_272,axiom,
    address(v7750_range_4_to_0_address_term_bound_14) ).

fof(address_association_224,axiom,
    v7750_range_4_to_0_address_association(constB14,v7750_range_4_to_0_address_term_bound_14) ).

fof(transient_address_definition_223,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_13,B)
    <=> v7750(constB13,B) ) ).

fof(is_address_271,axiom,
    address(v7750_range_4_to_0_address_term_bound_13) ).

fof(address_association_223,axiom,
    v7750_range_4_to_0_address_association(constB13,v7750_range_4_to_0_address_term_bound_13) ).

fof(transient_address_definition_222,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_12,B)
    <=> v7750(constB12,B) ) ).

fof(is_address_270,axiom,
    address(v7750_range_4_to_0_address_term_bound_12) ).

fof(address_association_222,axiom,
    v7750_range_4_to_0_address_association(constB12,v7750_range_4_to_0_address_term_bound_12) ).

fof(transient_address_definition_221,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_11,B)
    <=> v7750(constB11,B) ) ).

fof(is_address_269,axiom,
    address(v7750_range_4_to_0_address_term_bound_11) ).

fof(address_association_221,axiom,
    v7750_range_4_to_0_address_association(constB11,v7750_range_4_to_0_address_term_bound_11) ).

fof(transient_address_definition_220,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_10,B)
    <=> v7750(constB10,B) ) ).

fof(is_address_268,axiom,
    address(v7750_range_4_to_0_address_term_bound_10) ).

fof(address_association_220,axiom,
    v7750_range_4_to_0_address_association(constB10,v7750_range_4_to_0_address_term_bound_10) ).

fof(transient_address_definition_219,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_9,B)
    <=> v7750(constB9,B) ) ).

fof(is_address_267,axiom,
    address(v7750_range_4_to_0_address_term_bound_9) ).

fof(address_association_219,axiom,
    v7750_range_4_to_0_address_association(constB9,v7750_range_4_to_0_address_term_bound_9) ).

fof(transient_address_definition_218,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_8,B)
    <=> v7750(constB8,B) ) ).

fof(is_address_266,axiom,
    address(v7750_range_4_to_0_address_term_bound_8) ).

fof(address_association_218,axiom,
    v7750_range_4_to_0_address_association(constB8,v7750_range_4_to_0_address_term_bound_8) ).

fof(transient_address_definition_217,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_7,B)
    <=> v7750(constB7,B) ) ).

fof(is_address_265,axiom,
    address(v7750_range_4_to_0_address_term_bound_7) ).

fof(address_association_217,axiom,
    v7750_range_4_to_0_address_association(constB7,v7750_range_4_to_0_address_term_bound_7) ).

fof(transient_address_definition_216,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_6,B)
    <=> v7750(constB6,B) ) ).

fof(is_address_264,axiom,
    address(v7750_range_4_to_0_address_term_bound_6) ).

fof(address_association_216,axiom,
    v7750_range_4_to_0_address_association(constB6,v7750_range_4_to_0_address_term_bound_6) ).

fof(transient_address_definition_215,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_5,B)
    <=> v7750(constB5,B) ) ).

fof(is_address_263,axiom,
    address(v7750_range_4_to_0_address_term_bound_5) ).

fof(address_association_215,axiom,
    v7750_range_4_to_0_address_association(constB5,v7750_range_4_to_0_address_term_bound_5) ).

fof(transient_address_definition_214,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_4,B)
    <=> v7750(constB4,B) ) ).

fof(is_address_262,axiom,
    address(v7750_range_4_to_0_address_term_bound_4) ).

fof(address_association_214,axiom,
    v7750_range_4_to_0_address_association(constB4,v7750_range_4_to_0_address_term_bound_4) ).

fof(transient_address_definition_213,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_3,B)
    <=> v7750(constB3,B) ) ).

fof(is_address_261,axiom,
    address(v7750_range_4_to_0_address_term_bound_3) ).

fof(address_association_213,axiom,
    v7750_range_4_to_0_address_association(constB3,v7750_range_4_to_0_address_term_bound_3) ).

fof(transient_address_definition_212,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_2,B)
    <=> v7750(constB2,B) ) ).

fof(is_address_260,axiom,
    address(v7750_range_4_to_0_address_term_bound_2) ).

fof(address_association_212,axiom,
    v7750_range_4_to_0_address_association(constB2,v7750_range_4_to_0_address_term_bound_2) ).

fof(transient_address_definition_211,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_1,B)
    <=> v7750(constB1,B) ) ).

fof(is_address_259,axiom,
    address(v7750_range_4_to_0_address_term_bound_1) ).

fof(address_association_211,axiom,
    v7750_range_4_to_0_address_association(constB1,v7750_range_4_to_0_address_term_bound_1) ).

fof(transient_address_definition_210,axiom,
    ! [B] :
      ( addressVal(v7750_range_4_to_0_address_term_bound_0,B)
    <=> v7750(constB0,B) ) ).

fof(is_address_258,axiom,
    address(v7750_range_4_to_0_address_term_bound_0) ).

fof(address_association_210,axiom,
    v7750_range_4_to_0_address_association(constB0,v7750_range_4_to_0_address_term_bound_0) ).

fof(is_address_257,axiom,
    address(b11110_address_term) ).

fof(constant_address_definition_47,axiom,
    ! [B] :
      ( addressVal(b11110_address_term,B)
    <=> b11110(B) ) ).

fof(is_address_256,axiom,
    address(b11101_address_term) ).

fof(constant_address_definition_46,axiom,
    ! [B] :
      ( addressVal(b11101_address_term,B)
    <=> b11101(B) ) ).

fof(is_address_255,axiom,
    address(b11011_address_term) ).

fof(constant_address_definition_45,axiom,
    ! [B] :
      ( addressVal(b11011_address_term,B)
    <=> b11011(B) ) ).

fof(is_address_254,axiom,
    address(b11010_address_term) ).

fof(constant_address_definition_44,axiom,
    ! [B] :
      ( addressVal(b11010_address_term,B)
    <=> b11010(B) ) ).

fof(is_address_253,axiom,
    address(b11001_address_term) ).

fof(constant_address_definition_43,axiom,
    ! [B] :
      ( addressVal(b11001_address_term,B)
    <=> b11001(B) ) ).

fof(is_address_252,axiom,
    address(b10111_address_term) ).

fof(constant_address_definition_42,axiom,
    ! [B] :
      ( addressVal(b10111_address_term,B)
    <=> b10111(B) ) ).

fof(is_address_251,axiom,
    address(b10110_address_term) ).

fof(constant_address_definition_41,axiom,
    ! [B] :
      ( addressVal(b10110_address_term,B)
    <=> b10110(B) ) ).

fof(is_address_250,axiom,
    address(b10101_address_term) ).

fof(constant_address_definition_40,axiom,
    ! [B] :
      ( addressVal(b10101_address_term,B)
    <=> b10101(B) ) ).

fof(is_address_249,axiom,
    address(b01111_address_term) ).

fof(constant_address_definition_39,axiom,
    ! [B] :
      ( addressVal(b01111_address_term,B)
    <=> b01111(B) ) ).

fof(is_address_248,axiom,
    address(b01110_address_term) ).

fof(constant_address_definition_38,axiom,
    ! [B] :
      ( addressVal(b01110_address_term,B)
    <=> b01110(B) ) ).

fof(is_address_247,axiom,
    address(b01101_address_term) ).

fof(constant_address_definition_37,axiom,
    ! [B] :
      ( addressVal(b01101_address_term,B)
    <=> b01101(B) ) ).

fof(is_address_246,axiom,
    address(b01100_address_term) ).

fof(constant_address_definition_36,axiom,
    ! [B] :
      ( addressVal(b01100_address_term,B)
    <=> b01100(B) ) ).

fof(is_address_245,axiom,
    address(b01011_address_term) ).

fof(constant_address_definition_35,axiom,
    ! [B] :
      ( addressVal(b01011_address_term,B)
    <=> b01011(B) ) ).

fof(is_address_244,axiom,
    address(b01010_address_term) ).

fof(constant_address_definition_34,axiom,
    ! [B] :
      ( addressVal(b01010_address_term,B)
    <=> b01010(B) ) ).

fof(is_address_243,axiom,
    address(b01001_address_term) ).

fof(constant_address_definition_33,axiom,
    ! [B] :
      ( addressVal(b01001_address_term,B)
    <=> b01001(B) ) ).

fof(is_address_242,axiom,
    address(b01000_address_term) ).

fof(constant_address_definition_32,axiom,
    ! [B] :
      ( addressVal(b01000_address_term,B)
    <=> b01000(B) ) ).

fof(is_address_241,axiom,
    address(b00111_address_term) ).

fof(constant_address_definition_31,axiom,
    ! [B] :
      ( addressVal(b00111_address_term,B)
    <=> b00111(B) ) ).

fof(is_address_240,axiom,
    address(b00110_address_term) ).

fof(constant_address_definition_30,axiom,
    ! [B] :
      ( addressVal(b00110_address_term,B)
    <=> b00110(B) ) ).

fof(is_address_239,axiom,
    address(b00101_address_term) ).

fof(constant_address_definition_29,axiom,
    ! [B] :
      ( addressVal(b00101_address_term,B)
    <=> b00101(B) ) ).

fof(is_address_238,axiom,
    address(b00100_address_term) ).

fof(constant_address_definition_28,axiom,
    ! [B] :
      ( addressVal(b00100_address_term,B)
    <=> b00100(B) ) ).

fof(is_address_237,axiom,
    address(b00011_address_term) ).

fof(constant_address_definition_27,axiom,
    ! [B] :
      ( addressVal(b00011_address_term,B)
    <=> b00011(B) ) ).

fof(is_address_236,axiom,
    address(b00010_address_term) ).

fof(constant_address_definition_26,axiom,
    ! [B] :
      ( addressVal(b00010_address_term,B)
    <=> b00010(B) ) ).

fof(address_false_msb_204,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_20,bitIndex4) ).

fof(transient_address_definition_209,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_20,bitIndex0)
    <=> v6904(constB20,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_20,bitIndex1)
    <=> v6904(constB20,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_20,bitIndex2)
    <=> v6904(constB20,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_20,bitIndex3)
    <=> v6904(constB20,bitIndex3) ) ) ).

fof(is_address_235,axiom,
    address(v6904_range_3_to_0_address_term_bound_20) ).

fof(address_association_209,axiom,
    v6904_range_3_to_0_address_association(constB20,v6904_range_3_to_0_address_term_bound_20) ).

fof(address_false_msb_203,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_19,bitIndex4) ).

fof(transient_address_definition_208,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_19,bitIndex0)
    <=> v6904(constB19,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_19,bitIndex1)
    <=> v6904(constB19,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_19,bitIndex2)
    <=> v6904(constB19,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_19,bitIndex3)
    <=> v6904(constB19,bitIndex3) ) ) ).

fof(is_address_234,axiom,
    address(v6904_range_3_to_0_address_term_bound_19) ).

fof(address_association_208,axiom,
    v6904_range_3_to_0_address_association(constB19,v6904_range_3_to_0_address_term_bound_19) ).

fof(address_false_msb_202,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_18,bitIndex4) ).

fof(transient_address_definition_207,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_18,bitIndex0)
    <=> v6904(constB18,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_18,bitIndex1)
    <=> v6904(constB18,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_18,bitIndex2)
    <=> v6904(constB18,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_18,bitIndex3)
    <=> v6904(constB18,bitIndex3) ) ) ).

fof(is_address_233,axiom,
    address(v6904_range_3_to_0_address_term_bound_18) ).

fof(address_association_207,axiom,
    v6904_range_3_to_0_address_association(constB18,v6904_range_3_to_0_address_term_bound_18) ).

fof(address_false_msb_201,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_17,bitIndex4) ).

fof(transient_address_definition_206,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_17,bitIndex0)
    <=> v6904(constB17,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_17,bitIndex1)
    <=> v6904(constB17,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_17,bitIndex2)
    <=> v6904(constB17,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_17,bitIndex3)
    <=> v6904(constB17,bitIndex3) ) ) ).

fof(is_address_232,axiom,
    address(v6904_range_3_to_0_address_term_bound_17) ).

fof(address_association_206,axiom,
    v6904_range_3_to_0_address_association(constB17,v6904_range_3_to_0_address_term_bound_17) ).

fof(address_false_msb_200,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_16,bitIndex4) ).

fof(transient_address_definition_205,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_16,bitIndex0)
    <=> v6904(constB16,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_16,bitIndex1)
    <=> v6904(constB16,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_16,bitIndex2)
    <=> v6904(constB16,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_16,bitIndex3)
    <=> v6904(constB16,bitIndex3) ) ) ).

fof(is_address_231,axiom,
    address(v6904_range_3_to_0_address_term_bound_16) ).

fof(address_association_205,axiom,
    v6904_range_3_to_0_address_association(constB16,v6904_range_3_to_0_address_term_bound_16) ).

fof(address_false_msb_199,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_15,bitIndex4) ).

fof(transient_address_definition_204,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_15,bitIndex0)
    <=> v6904(constB15,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_15,bitIndex1)
    <=> v6904(constB15,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_15,bitIndex2)
    <=> v6904(constB15,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_15,bitIndex3)
    <=> v6904(constB15,bitIndex3) ) ) ).

fof(is_address_230,axiom,
    address(v6904_range_3_to_0_address_term_bound_15) ).

fof(address_association_204,axiom,
    v6904_range_3_to_0_address_association(constB15,v6904_range_3_to_0_address_term_bound_15) ).

fof(address_false_msb_198,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_14,bitIndex4) ).

fof(transient_address_definition_203,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_14,bitIndex0)
    <=> v6904(constB14,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_14,bitIndex1)
    <=> v6904(constB14,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_14,bitIndex2)
    <=> v6904(constB14,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_14,bitIndex3)
    <=> v6904(constB14,bitIndex3) ) ) ).

fof(is_address_229,axiom,
    address(v6904_range_3_to_0_address_term_bound_14) ).

fof(address_association_203,axiom,
    v6904_range_3_to_0_address_association(constB14,v6904_range_3_to_0_address_term_bound_14) ).

fof(address_false_msb_197,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_13,bitIndex4) ).

fof(transient_address_definition_202,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_13,bitIndex0)
    <=> v6904(constB13,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_13,bitIndex1)
    <=> v6904(constB13,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_13,bitIndex2)
    <=> v6904(constB13,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_13,bitIndex3)
    <=> v6904(constB13,bitIndex3) ) ) ).

fof(is_address_228,axiom,
    address(v6904_range_3_to_0_address_term_bound_13) ).

fof(address_association_202,axiom,
    v6904_range_3_to_0_address_association(constB13,v6904_range_3_to_0_address_term_bound_13) ).

fof(address_false_msb_196,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_12,bitIndex4) ).

fof(transient_address_definition_201,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_12,bitIndex0)
    <=> v6904(constB12,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_12,bitIndex1)
    <=> v6904(constB12,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_12,bitIndex2)
    <=> v6904(constB12,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_12,bitIndex3)
    <=> v6904(constB12,bitIndex3) ) ) ).

fof(is_address_227,axiom,
    address(v6904_range_3_to_0_address_term_bound_12) ).

fof(address_association_201,axiom,
    v6904_range_3_to_0_address_association(constB12,v6904_range_3_to_0_address_term_bound_12) ).

fof(address_false_msb_195,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_11,bitIndex4) ).

fof(transient_address_definition_200,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_11,bitIndex0)
    <=> v6904(constB11,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_11,bitIndex1)
    <=> v6904(constB11,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_11,bitIndex2)
    <=> v6904(constB11,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_11,bitIndex3)
    <=> v6904(constB11,bitIndex3) ) ) ).

fof(is_address_226,axiom,
    address(v6904_range_3_to_0_address_term_bound_11) ).

fof(address_association_200,axiom,
    v6904_range_3_to_0_address_association(constB11,v6904_range_3_to_0_address_term_bound_11) ).

fof(address_false_msb_194,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_10,bitIndex4) ).

fof(transient_address_definition_199,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_10,bitIndex0)
    <=> v6904(constB10,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_10,bitIndex1)
    <=> v6904(constB10,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_10,bitIndex2)
    <=> v6904(constB10,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_10,bitIndex3)
    <=> v6904(constB10,bitIndex3) ) ) ).

fof(is_address_225,axiom,
    address(v6904_range_3_to_0_address_term_bound_10) ).

fof(address_association_199,axiom,
    v6904_range_3_to_0_address_association(constB10,v6904_range_3_to_0_address_term_bound_10) ).

fof(address_false_msb_193,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_9,bitIndex4) ).

fof(transient_address_definition_198,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_9,bitIndex0)
    <=> v6904(constB9,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_9,bitIndex1)
    <=> v6904(constB9,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_9,bitIndex2)
    <=> v6904(constB9,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_9,bitIndex3)
    <=> v6904(constB9,bitIndex3) ) ) ).

fof(is_address_224,axiom,
    address(v6904_range_3_to_0_address_term_bound_9) ).

fof(address_association_198,axiom,
    v6904_range_3_to_0_address_association(constB9,v6904_range_3_to_0_address_term_bound_9) ).

fof(address_false_msb_192,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_8,bitIndex4) ).

fof(transient_address_definition_197,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_8,bitIndex0)
    <=> v6904(constB8,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_8,bitIndex1)
    <=> v6904(constB8,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_8,bitIndex2)
    <=> v6904(constB8,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_8,bitIndex3)
    <=> v6904(constB8,bitIndex3) ) ) ).

fof(is_address_223,axiom,
    address(v6904_range_3_to_0_address_term_bound_8) ).

fof(address_association_197,axiom,
    v6904_range_3_to_0_address_association(constB8,v6904_range_3_to_0_address_term_bound_8) ).

fof(address_false_msb_191,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_7,bitIndex4) ).

fof(transient_address_definition_196,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_7,bitIndex0)
    <=> v6904(constB7,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_7,bitIndex1)
    <=> v6904(constB7,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_7,bitIndex2)
    <=> v6904(constB7,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_7,bitIndex3)
    <=> v6904(constB7,bitIndex3) ) ) ).

fof(is_address_222,axiom,
    address(v6904_range_3_to_0_address_term_bound_7) ).

fof(address_association_196,axiom,
    v6904_range_3_to_0_address_association(constB7,v6904_range_3_to_0_address_term_bound_7) ).

fof(address_false_msb_190,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_6,bitIndex4) ).

fof(transient_address_definition_195,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_6,bitIndex0)
    <=> v6904(constB6,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_6,bitIndex1)
    <=> v6904(constB6,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_6,bitIndex2)
    <=> v6904(constB6,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_6,bitIndex3)
    <=> v6904(constB6,bitIndex3) ) ) ).

fof(is_address_221,axiom,
    address(v6904_range_3_to_0_address_term_bound_6) ).

fof(address_association_195,axiom,
    v6904_range_3_to_0_address_association(constB6,v6904_range_3_to_0_address_term_bound_6) ).

fof(address_false_msb_189,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_5,bitIndex4) ).

fof(transient_address_definition_194,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_5,bitIndex0)
    <=> v6904(constB5,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_5,bitIndex1)
    <=> v6904(constB5,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_5,bitIndex2)
    <=> v6904(constB5,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_5,bitIndex3)
    <=> v6904(constB5,bitIndex3) ) ) ).

fof(is_address_220,axiom,
    address(v6904_range_3_to_0_address_term_bound_5) ).

fof(address_association_194,axiom,
    v6904_range_3_to_0_address_association(constB5,v6904_range_3_to_0_address_term_bound_5) ).

fof(address_false_msb_188,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_4,bitIndex4) ).

fof(transient_address_definition_193,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_4,bitIndex0)
    <=> v6904(constB4,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_4,bitIndex1)
    <=> v6904(constB4,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_4,bitIndex2)
    <=> v6904(constB4,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_4,bitIndex3)
    <=> v6904(constB4,bitIndex3) ) ) ).

fof(is_address_219,axiom,
    address(v6904_range_3_to_0_address_term_bound_4) ).

fof(address_association_193,axiom,
    v6904_range_3_to_0_address_association(constB4,v6904_range_3_to_0_address_term_bound_4) ).

fof(address_false_msb_187,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_3,bitIndex4) ).

fof(transient_address_definition_192,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_3,bitIndex0)
    <=> v6904(constB3,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_3,bitIndex1)
    <=> v6904(constB3,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_3,bitIndex2)
    <=> v6904(constB3,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_3,bitIndex3)
    <=> v6904(constB3,bitIndex3) ) ) ).

fof(is_address_218,axiom,
    address(v6904_range_3_to_0_address_term_bound_3) ).

fof(address_association_192,axiom,
    v6904_range_3_to_0_address_association(constB3,v6904_range_3_to_0_address_term_bound_3) ).

fof(address_false_msb_186,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_2,bitIndex4) ).

fof(transient_address_definition_191,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_2,bitIndex0)
    <=> v6904(constB2,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_2,bitIndex1)
    <=> v6904(constB2,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_2,bitIndex2)
    <=> v6904(constB2,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_2,bitIndex3)
    <=> v6904(constB2,bitIndex3) ) ) ).

fof(is_address_217,axiom,
    address(v6904_range_3_to_0_address_term_bound_2) ).

fof(address_association_191,axiom,
    v6904_range_3_to_0_address_association(constB2,v6904_range_3_to_0_address_term_bound_2) ).

fof(address_false_msb_185,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_1,bitIndex4) ).

fof(transient_address_definition_190,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_1,bitIndex0)
    <=> v6904(constB1,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_1,bitIndex1)
    <=> v6904(constB1,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_1,bitIndex2)
    <=> v6904(constB1,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_1,bitIndex3)
    <=> v6904(constB1,bitIndex3) ) ) ).

fof(is_address_216,axiom,
    address(v6904_range_3_to_0_address_term_bound_1) ).

fof(address_association_190,axiom,
    v6904_range_3_to_0_address_association(constB1,v6904_range_3_to_0_address_term_bound_1) ).

fof(address_false_msb_184,axiom,
    ~ addressVal(v6904_range_3_to_0_address_term_bound_0,bitIndex4) ).

fof(transient_address_definition_189,axiom,
    ( $true
    & ( addressVal(v6904_range_3_to_0_address_term_bound_0,bitIndex0)
    <=> v6904(constB0,bitIndex0) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_0,bitIndex1)
    <=> v6904(constB0,bitIndex1) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_0,bitIndex2)
    <=> v6904(constB0,bitIndex2) )
    & ( addressVal(v6904_range_3_to_0_address_term_bound_0,bitIndex3)
    <=> v6904(constB0,bitIndex3) ) ) ).

fof(is_address_215,axiom,
    address(v6904_range_3_to_0_address_term_bound_0) ).

fof(address_association_189,axiom,
    v6904_range_3_to_0_address_association(constB0,v6904_range_3_to_0_address_term_bound_0) ).

fof(transient_address_definition_188,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_20,B)
    <=> v6281(constB20,B) ) ).

fof(is_address_214,axiom,
    address(v6281_range_4_to_0_address_term_bound_20) ).

fof(address_association_188,axiom,
    v6281_range_4_to_0_address_association(constB20,v6281_range_4_to_0_address_term_bound_20) ).

fof(transient_address_definition_187,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_19,B)
    <=> v6281(constB19,B) ) ).

fof(is_address_213,axiom,
    address(v6281_range_4_to_0_address_term_bound_19) ).

fof(address_association_187,axiom,
    v6281_range_4_to_0_address_association(constB19,v6281_range_4_to_0_address_term_bound_19) ).

fof(transient_address_definition_186,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_18,B)
    <=> v6281(constB18,B) ) ).

fof(is_address_212,axiom,
    address(v6281_range_4_to_0_address_term_bound_18) ).

fof(address_association_186,axiom,
    v6281_range_4_to_0_address_association(constB18,v6281_range_4_to_0_address_term_bound_18) ).

fof(transient_address_definition_185,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_17,B)
    <=> v6281(constB17,B) ) ).

fof(is_address_211,axiom,
    address(v6281_range_4_to_0_address_term_bound_17) ).

fof(address_association_185,axiom,
    v6281_range_4_to_0_address_association(constB17,v6281_range_4_to_0_address_term_bound_17) ).

fof(transient_address_definition_184,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_16,B)
    <=> v6281(constB16,B) ) ).

fof(is_address_210,axiom,
    address(v6281_range_4_to_0_address_term_bound_16) ).

fof(address_association_184,axiom,
    v6281_range_4_to_0_address_association(constB16,v6281_range_4_to_0_address_term_bound_16) ).

fof(transient_address_definition_183,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_15,B)
    <=> v6281(constB15,B) ) ).

fof(is_address_209,axiom,
    address(v6281_range_4_to_0_address_term_bound_15) ).

fof(address_association_183,axiom,
    v6281_range_4_to_0_address_association(constB15,v6281_range_4_to_0_address_term_bound_15) ).

fof(transient_address_definition_182,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_14,B)
    <=> v6281(constB14,B) ) ).

fof(is_address_208,axiom,
    address(v6281_range_4_to_0_address_term_bound_14) ).

fof(address_association_182,axiom,
    v6281_range_4_to_0_address_association(constB14,v6281_range_4_to_0_address_term_bound_14) ).

fof(transient_address_definition_181,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_13,B)
    <=> v6281(constB13,B) ) ).

fof(is_address_207,axiom,
    address(v6281_range_4_to_0_address_term_bound_13) ).

fof(address_association_181,axiom,
    v6281_range_4_to_0_address_association(constB13,v6281_range_4_to_0_address_term_bound_13) ).

fof(transient_address_definition_180,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_12,B)
    <=> v6281(constB12,B) ) ).

fof(is_address_206,axiom,
    address(v6281_range_4_to_0_address_term_bound_12) ).

fof(address_association_180,axiom,
    v6281_range_4_to_0_address_association(constB12,v6281_range_4_to_0_address_term_bound_12) ).

fof(transient_address_definition_179,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_11,B)
    <=> v6281(constB11,B) ) ).

fof(is_address_205,axiom,
    address(v6281_range_4_to_0_address_term_bound_11) ).

fof(address_association_179,axiom,
    v6281_range_4_to_0_address_association(constB11,v6281_range_4_to_0_address_term_bound_11) ).

fof(transient_address_definition_178,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_10,B)
    <=> v6281(constB10,B) ) ).

fof(is_address_204,axiom,
    address(v6281_range_4_to_0_address_term_bound_10) ).

fof(address_association_178,axiom,
    v6281_range_4_to_0_address_association(constB10,v6281_range_4_to_0_address_term_bound_10) ).

fof(transient_address_definition_177,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_9,B)
    <=> v6281(constB9,B) ) ).

fof(is_address_203,axiom,
    address(v6281_range_4_to_0_address_term_bound_9) ).

fof(address_association_177,axiom,
    v6281_range_4_to_0_address_association(constB9,v6281_range_4_to_0_address_term_bound_9) ).

fof(transient_address_definition_176,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_8,B)
    <=> v6281(constB8,B) ) ).

fof(is_address_202,axiom,
    address(v6281_range_4_to_0_address_term_bound_8) ).

fof(address_association_176,axiom,
    v6281_range_4_to_0_address_association(constB8,v6281_range_4_to_0_address_term_bound_8) ).

fof(transient_address_definition_175,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_7,B)
    <=> v6281(constB7,B) ) ).

fof(is_address_201,axiom,
    address(v6281_range_4_to_0_address_term_bound_7) ).

fof(address_association_175,axiom,
    v6281_range_4_to_0_address_association(constB7,v6281_range_4_to_0_address_term_bound_7) ).

fof(transient_address_definition_174,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_6,B)
    <=> v6281(constB6,B) ) ).

fof(is_address_200,axiom,
    address(v6281_range_4_to_0_address_term_bound_6) ).

fof(address_association_174,axiom,
    v6281_range_4_to_0_address_association(constB6,v6281_range_4_to_0_address_term_bound_6) ).

fof(transient_address_definition_173,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_5,B)
    <=> v6281(constB5,B) ) ).

fof(is_address_199,axiom,
    address(v6281_range_4_to_0_address_term_bound_5) ).

fof(address_association_173,axiom,
    v6281_range_4_to_0_address_association(constB5,v6281_range_4_to_0_address_term_bound_5) ).

fof(transient_address_definition_172,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_4,B)
    <=> v6281(constB4,B) ) ).

fof(is_address_198,axiom,
    address(v6281_range_4_to_0_address_term_bound_4) ).

fof(address_association_172,axiom,
    v6281_range_4_to_0_address_association(constB4,v6281_range_4_to_0_address_term_bound_4) ).

fof(transient_address_definition_171,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_3,B)
    <=> v6281(constB3,B) ) ).

fof(is_address_197,axiom,
    address(v6281_range_4_to_0_address_term_bound_3) ).

fof(address_association_171,axiom,
    v6281_range_4_to_0_address_association(constB3,v6281_range_4_to_0_address_term_bound_3) ).

fof(transient_address_definition_170,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_2,B)
    <=> v6281(constB2,B) ) ).

fof(is_address_196,axiom,
    address(v6281_range_4_to_0_address_term_bound_2) ).

fof(address_association_170,axiom,
    v6281_range_4_to_0_address_association(constB2,v6281_range_4_to_0_address_term_bound_2) ).

fof(transient_address_definition_169,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_1,B)
    <=> v6281(constB1,B) ) ).

fof(is_address_195,axiom,
    address(v6281_range_4_to_0_address_term_bound_1) ).

fof(address_association_169,axiom,
    v6281_range_4_to_0_address_association(constB1,v6281_range_4_to_0_address_term_bound_1) ).

fof(transient_address_definition_168,axiom,
    ! [B] :
      ( addressVal(v6281_range_4_to_0_address_term_bound_0,B)
    <=> v6281(constB0,B) ) ).

fof(is_address_194,axiom,
    address(v6281_range_4_to_0_address_term_bound_0) ).

fof(address_association_168,axiom,
    v6281_range_4_to_0_address_association(constB0,v6281_range_4_to_0_address_term_bound_0) ).

fof(transient_address_definition_167,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_20,B)
    <=> v6241(constB20,B) ) ).

fof(is_address_193,axiom,
    address(v6241_range_4_to_0_address_term_bound_20) ).

fof(address_association_167,axiom,
    v6241_range_4_to_0_address_association(constB20,v6241_range_4_to_0_address_term_bound_20) ).

fof(transient_address_definition_166,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_19,B)
    <=> v6241(constB19,B) ) ).

fof(is_address_192,axiom,
    address(v6241_range_4_to_0_address_term_bound_19) ).

fof(address_association_166,axiom,
    v6241_range_4_to_0_address_association(constB19,v6241_range_4_to_0_address_term_bound_19) ).

fof(transient_address_definition_165,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_18,B)
    <=> v6241(constB18,B) ) ).

fof(is_address_191,axiom,
    address(v6241_range_4_to_0_address_term_bound_18) ).

fof(address_association_165,axiom,
    v6241_range_4_to_0_address_association(constB18,v6241_range_4_to_0_address_term_bound_18) ).

fof(transient_address_definition_164,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_17,B)
    <=> v6241(constB17,B) ) ).

fof(is_address_190,axiom,
    address(v6241_range_4_to_0_address_term_bound_17) ).

fof(address_association_164,axiom,
    v6241_range_4_to_0_address_association(constB17,v6241_range_4_to_0_address_term_bound_17) ).

fof(transient_address_definition_163,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_16,B)
    <=> v6241(constB16,B) ) ).

fof(is_address_189,axiom,
    address(v6241_range_4_to_0_address_term_bound_16) ).

fof(address_association_163,axiom,
    v6241_range_4_to_0_address_association(constB16,v6241_range_4_to_0_address_term_bound_16) ).

fof(transient_address_definition_162,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_15,B)
    <=> v6241(constB15,B) ) ).

fof(is_address_188,axiom,
    address(v6241_range_4_to_0_address_term_bound_15) ).

fof(address_association_162,axiom,
    v6241_range_4_to_0_address_association(constB15,v6241_range_4_to_0_address_term_bound_15) ).

fof(transient_address_definition_161,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_14,B)
    <=> v6241(constB14,B) ) ).

fof(is_address_187,axiom,
    address(v6241_range_4_to_0_address_term_bound_14) ).

fof(address_association_161,axiom,
    v6241_range_4_to_0_address_association(constB14,v6241_range_4_to_0_address_term_bound_14) ).

fof(transient_address_definition_160,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_13,B)
    <=> v6241(constB13,B) ) ).

fof(is_address_186,axiom,
    address(v6241_range_4_to_0_address_term_bound_13) ).

fof(address_association_160,axiom,
    v6241_range_4_to_0_address_association(constB13,v6241_range_4_to_0_address_term_bound_13) ).

fof(transient_address_definition_159,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_12,B)
    <=> v6241(constB12,B) ) ).

fof(is_address_185,axiom,
    address(v6241_range_4_to_0_address_term_bound_12) ).

fof(address_association_159,axiom,
    v6241_range_4_to_0_address_association(constB12,v6241_range_4_to_0_address_term_bound_12) ).

fof(transient_address_definition_158,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_11,B)
    <=> v6241(constB11,B) ) ).

fof(is_address_184,axiom,
    address(v6241_range_4_to_0_address_term_bound_11) ).

fof(address_association_158,axiom,
    v6241_range_4_to_0_address_association(constB11,v6241_range_4_to_0_address_term_bound_11) ).

fof(transient_address_definition_157,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_10,B)
    <=> v6241(constB10,B) ) ).

fof(is_address_183,axiom,
    address(v6241_range_4_to_0_address_term_bound_10) ).

fof(address_association_157,axiom,
    v6241_range_4_to_0_address_association(constB10,v6241_range_4_to_0_address_term_bound_10) ).

fof(transient_address_definition_156,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_9,B)
    <=> v6241(constB9,B) ) ).

fof(is_address_182,axiom,
    address(v6241_range_4_to_0_address_term_bound_9) ).

fof(address_association_156,axiom,
    v6241_range_4_to_0_address_association(constB9,v6241_range_4_to_0_address_term_bound_9) ).

fof(transient_address_definition_155,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_8,B)
    <=> v6241(constB8,B) ) ).

fof(is_address_181,axiom,
    address(v6241_range_4_to_0_address_term_bound_8) ).

fof(address_association_155,axiom,
    v6241_range_4_to_0_address_association(constB8,v6241_range_4_to_0_address_term_bound_8) ).

fof(transient_address_definition_154,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_7,B)
    <=> v6241(constB7,B) ) ).

fof(is_address_180,axiom,
    address(v6241_range_4_to_0_address_term_bound_7) ).

fof(address_association_154,axiom,
    v6241_range_4_to_0_address_association(constB7,v6241_range_4_to_0_address_term_bound_7) ).

fof(transient_address_definition_153,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_6,B)
    <=> v6241(constB6,B) ) ).

fof(is_address_179,axiom,
    address(v6241_range_4_to_0_address_term_bound_6) ).

fof(address_association_153,axiom,
    v6241_range_4_to_0_address_association(constB6,v6241_range_4_to_0_address_term_bound_6) ).

fof(transient_address_definition_152,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_5,B)
    <=> v6241(constB5,B) ) ).

fof(is_address_178,axiom,
    address(v6241_range_4_to_0_address_term_bound_5) ).

fof(address_association_152,axiom,
    v6241_range_4_to_0_address_association(constB5,v6241_range_4_to_0_address_term_bound_5) ).

fof(transient_address_definition_151,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_4,B)
    <=> v6241(constB4,B) ) ).

fof(is_address_177,axiom,
    address(v6241_range_4_to_0_address_term_bound_4) ).

fof(address_association_151,axiom,
    v6241_range_4_to_0_address_association(constB4,v6241_range_4_to_0_address_term_bound_4) ).

fof(transient_address_definition_150,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_3,B)
    <=> v6241(constB3,B) ) ).

fof(is_address_176,axiom,
    address(v6241_range_4_to_0_address_term_bound_3) ).

fof(address_association_150,axiom,
    v6241_range_4_to_0_address_association(constB3,v6241_range_4_to_0_address_term_bound_3) ).

fof(transient_address_definition_149,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_2,B)
    <=> v6241(constB2,B) ) ).

fof(is_address_175,axiom,
    address(v6241_range_4_to_0_address_term_bound_2) ).

fof(address_association_149,axiom,
    v6241_range_4_to_0_address_association(constB2,v6241_range_4_to_0_address_term_bound_2) ).

fof(transient_address_definition_148,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_1,B)
    <=> v6241(constB1,B) ) ).

fof(is_address_174,axiom,
    address(v6241_range_4_to_0_address_term_bound_1) ).

fof(address_association_148,axiom,
    v6241_range_4_to_0_address_association(constB1,v6241_range_4_to_0_address_term_bound_1) ).

fof(transient_address_definition_147,axiom,
    ! [B] :
      ( addressVal(v6241_range_4_to_0_address_term_bound_0,B)
    <=> v6241(constB0,B) ) ).

fof(is_address_173,axiom,
    address(v6241_range_4_to_0_address_term_bound_0) ).

fof(address_association_147,axiom,
    v6241_range_4_to_0_address_association(constB0,v6241_range_4_to_0_address_term_bound_0) ).

fof(transient_address_definition_146,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_20,B)
    <=> v5575(constB20,B) ) ).

fof(is_address_172,axiom,
    address(v5575_range_4_to_0_address_term_bound_20) ).

fof(address_association_146,axiom,
    v5575_range_4_to_0_address_association(constB20,v5575_range_4_to_0_address_term_bound_20) ).

fof(transient_address_definition_145,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_19,B)
    <=> v5575(constB19,B) ) ).

fof(is_address_171,axiom,
    address(v5575_range_4_to_0_address_term_bound_19) ).

fof(address_association_145,axiom,
    v5575_range_4_to_0_address_association(constB19,v5575_range_4_to_0_address_term_bound_19) ).

fof(transient_address_definition_144,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_18,B)
    <=> v5575(constB18,B) ) ).

fof(is_address_170,axiom,
    address(v5575_range_4_to_0_address_term_bound_18) ).

fof(address_association_144,axiom,
    v5575_range_4_to_0_address_association(constB18,v5575_range_4_to_0_address_term_bound_18) ).

fof(transient_address_definition_143,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_17,B)
    <=> v5575(constB17,B) ) ).

fof(is_address_169,axiom,
    address(v5575_range_4_to_0_address_term_bound_17) ).

fof(address_association_143,axiom,
    v5575_range_4_to_0_address_association(constB17,v5575_range_4_to_0_address_term_bound_17) ).

fof(transient_address_definition_142,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_16,B)
    <=> v5575(constB16,B) ) ).

fof(is_address_168,axiom,
    address(v5575_range_4_to_0_address_term_bound_16) ).

fof(address_association_142,axiom,
    v5575_range_4_to_0_address_association(constB16,v5575_range_4_to_0_address_term_bound_16) ).

fof(transient_address_definition_141,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_15,B)
    <=> v5575(constB15,B) ) ).

fof(is_address_167,axiom,
    address(v5575_range_4_to_0_address_term_bound_15) ).

fof(address_association_141,axiom,
    v5575_range_4_to_0_address_association(constB15,v5575_range_4_to_0_address_term_bound_15) ).

fof(transient_address_definition_140,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_14,B)
    <=> v5575(constB14,B) ) ).

fof(is_address_166,axiom,
    address(v5575_range_4_to_0_address_term_bound_14) ).

fof(address_association_140,axiom,
    v5575_range_4_to_0_address_association(constB14,v5575_range_4_to_0_address_term_bound_14) ).

fof(transient_address_definition_139,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_13,B)
    <=> v5575(constB13,B) ) ).

fof(is_address_165,axiom,
    address(v5575_range_4_to_0_address_term_bound_13) ).

fof(address_association_139,axiom,
    v5575_range_4_to_0_address_association(constB13,v5575_range_4_to_0_address_term_bound_13) ).

fof(transient_address_definition_138,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_12,B)
    <=> v5575(constB12,B) ) ).

fof(is_address_164,axiom,
    address(v5575_range_4_to_0_address_term_bound_12) ).

fof(address_association_138,axiom,
    v5575_range_4_to_0_address_association(constB12,v5575_range_4_to_0_address_term_bound_12) ).

fof(transient_address_definition_137,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_11,B)
    <=> v5575(constB11,B) ) ).

fof(is_address_163,axiom,
    address(v5575_range_4_to_0_address_term_bound_11) ).

fof(address_association_137,axiom,
    v5575_range_4_to_0_address_association(constB11,v5575_range_4_to_0_address_term_bound_11) ).

fof(transient_address_definition_136,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_10,B)
    <=> v5575(constB10,B) ) ).

fof(is_address_162,axiom,
    address(v5575_range_4_to_0_address_term_bound_10) ).

fof(address_association_136,axiom,
    v5575_range_4_to_0_address_association(constB10,v5575_range_4_to_0_address_term_bound_10) ).

fof(transient_address_definition_135,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_9,B)
    <=> v5575(constB9,B) ) ).

fof(is_address_161,axiom,
    address(v5575_range_4_to_0_address_term_bound_9) ).

fof(address_association_135,axiom,
    v5575_range_4_to_0_address_association(constB9,v5575_range_4_to_0_address_term_bound_9) ).

fof(transient_address_definition_134,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_8,B)
    <=> v5575(constB8,B) ) ).

fof(is_address_160,axiom,
    address(v5575_range_4_to_0_address_term_bound_8) ).

fof(address_association_134,axiom,
    v5575_range_4_to_0_address_association(constB8,v5575_range_4_to_0_address_term_bound_8) ).

fof(transient_address_definition_133,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_7,B)
    <=> v5575(constB7,B) ) ).

fof(is_address_159,axiom,
    address(v5575_range_4_to_0_address_term_bound_7) ).

fof(address_association_133,axiom,
    v5575_range_4_to_0_address_association(constB7,v5575_range_4_to_0_address_term_bound_7) ).

fof(transient_address_definition_132,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_6,B)
    <=> v5575(constB6,B) ) ).

fof(is_address_158,axiom,
    address(v5575_range_4_to_0_address_term_bound_6) ).

fof(address_association_132,axiom,
    v5575_range_4_to_0_address_association(constB6,v5575_range_4_to_0_address_term_bound_6) ).

fof(transient_address_definition_131,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_5,B)
    <=> v5575(constB5,B) ) ).

fof(is_address_157,axiom,
    address(v5575_range_4_to_0_address_term_bound_5) ).

fof(address_association_131,axiom,
    v5575_range_4_to_0_address_association(constB5,v5575_range_4_to_0_address_term_bound_5) ).

fof(transient_address_definition_130,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_4,B)
    <=> v5575(constB4,B) ) ).

fof(is_address_156,axiom,
    address(v5575_range_4_to_0_address_term_bound_4) ).

fof(address_association_130,axiom,
    v5575_range_4_to_0_address_association(constB4,v5575_range_4_to_0_address_term_bound_4) ).

fof(transient_address_definition_129,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_3,B)
    <=> v5575(constB3,B) ) ).

fof(is_address_155,axiom,
    address(v5575_range_4_to_0_address_term_bound_3) ).

fof(address_association_129,axiom,
    v5575_range_4_to_0_address_association(constB3,v5575_range_4_to_0_address_term_bound_3) ).

fof(transient_address_definition_128,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_2,B)
    <=> v5575(constB2,B) ) ).

fof(is_address_154,axiom,
    address(v5575_range_4_to_0_address_term_bound_2) ).

fof(address_association_128,axiom,
    v5575_range_4_to_0_address_association(constB2,v5575_range_4_to_0_address_term_bound_2) ).

fof(transient_address_definition_127,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_1,B)
    <=> v5575(constB1,B) ) ).

fof(is_address_153,axiom,
    address(v5575_range_4_to_0_address_term_bound_1) ).

fof(address_association_127,axiom,
    v5575_range_4_to_0_address_association(constB1,v5575_range_4_to_0_address_term_bound_1) ).

fof(transient_address_definition_126,axiom,
    ! [B] :
      ( addressVal(v5575_range_4_to_0_address_term_bound_0,B)
    <=> v5575(constB0,B) ) ).

fof(is_address_152,axiom,
    address(v5575_range_4_to_0_address_term_bound_0) ).

fof(address_association_126,axiom,
    v5575_range_4_to_0_address_association(constB0,v5575_range_4_to_0_address_term_bound_0) ).

fof(is_address_151,axiom,
    address(b11100_address_term) ).

fof(constant_address_definition_25,axiom,
    ! [B] :
      ( addressVal(b11100_address_term,B)
    <=> b11100(B) ) ).

fof(is_address_150,axiom,
    address(b10011_address_term) ).

fof(constant_address_definition_24,axiom,
    ! [B] :
      ( addressVal(b10011_address_term,B)
    <=> b10011(B) ) ).

fof(is_address_149,axiom,
    address(b11000_address_term) ).

fof(constant_address_definition_23,axiom,
    ! [B] :
      ( addressVal(b11000_address_term,B)
    <=> b11000(B) ) ).

fof(is_address_148,axiom,
    address(b10100_address_term) ).

fof(constant_address_definition_22,axiom,
    ! [B] :
      ( addressVal(b10100_address_term,B)
    <=> b10100(B) ) ).

fof(is_address_147,axiom,
    address(b10010_address_term) ).

fof(constant_address_definition_21,axiom,
    ! [B] :
      ( addressVal(b10010_address_term,B)
    <=> b10010(B) ) ).

fof(is_address_146,axiom,
    address(b10001_address_term) ).

fof(constant_address_definition_20,axiom,
    ! [B] :
      ( addressVal(b10001_address_term,B)
    <=> b10001(B) ) ).

fof(address_false_msb_183,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_20,bitIndex4) ).

fof(address_false_msb_182,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_20,bitIndex3) ).

fof(transient_address_definition_125,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_20,bitIndex0)
    <=> v4049(constB20,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_20,bitIndex1)
    <=> v4049(constB20,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_20,bitIndex2)
    <=> v4049(constB20,bitIndex2) ) ) ).

fof(is_address_145,axiom,
    address(v4049_range_2_to_0_address_term_bound_20) ).

fof(address_association_125,axiom,
    v4049_range_2_to_0_address_association(constB20,v4049_range_2_to_0_address_term_bound_20) ).

fof(address_false_msb_181,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_19,bitIndex4) ).

fof(address_false_msb_180,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_19,bitIndex3) ).

fof(transient_address_definition_124,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_19,bitIndex0)
    <=> v4049(constB19,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_19,bitIndex1)
    <=> v4049(constB19,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_19,bitIndex2)
    <=> v4049(constB19,bitIndex2) ) ) ).

fof(is_address_144,axiom,
    address(v4049_range_2_to_0_address_term_bound_19) ).

fof(address_association_124,axiom,
    v4049_range_2_to_0_address_association(constB19,v4049_range_2_to_0_address_term_bound_19) ).

fof(address_false_msb_179,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_18,bitIndex4) ).

fof(address_false_msb_178,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_18,bitIndex3) ).

fof(transient_address_definition_123,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_18,bitIndex0)
    <=> v4049(constB18,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_18,bitIndex1)
    <=> v4049(constB18,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_18,bitIndex2)
    <=> v4049(constB18,bitIndex2) ) ) ).

fof(is_address_143,axiom,
    address(v4049_range_2_to_0_address_term_bound_18) ).

fof(address_association_123,axiom,
    v4049_range_2_to_0_address_association(constB18,v4049_range_2_to_0_address_term_bound_18) ).

fof(address_false_msb_177,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_17,bitIndex4) ).

fof(address_false_msb_176,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_17,bitIndex3) ).

fof(transient_address_definition_122,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_17,bitIndex0)
    <=> v4049(constB17,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_17,bitIndex1)
    <=> v4049(constB17,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_17,bitIndex2)
    <=> v4049(constB17,bitIndex2) ) ) ).

fof(is_address_142,axiom,
    address(v4049_range_2_to_0_address_term_bound_17) ).

fof(address_association_122,axiom,
    v4049_range_2_to_0_address_association(constB17,v4049_range_2_to_0_address_term_bound_17) ).

fof(address_false_msb_175,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_16,bitIndex4) ).

fof(address_false_msb_174,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_16,bitIndex3) ).

fof(transient_address_definition_121,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_16,bitIndex0)
    <=> v4049(constB16,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_16,bitIndex1)
    <=> v4049(constB16,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_16,bitIndex2)
    <=> v4049(constB16,bitIndex2) ) ) ).

fof(is_address_141,axiom,
    address(v4049_range_2_to_0_address_term_bound_16) ).

fof(address_association_121,axiom,
    v4049_range_2_to_0_address_association(constB16,v4049_range_2_to_0_address_term_bound_16) ).

fof(address_false_msb_173,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_15,bitIndex4) ).

fof(address_false_msb_172,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_15,bitIndex3) ).

fof(transient_address_definition_120,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_15,bitIndex0)
    <=> v4049(constB15,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_15,bitIndex1)
    <=> v4049(constB15,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_15,bitIndex2)
    <=> v4049(constB15,bitIndex2) ) ) ).

fof(is_address_140,axiom,
    address(v4049_range_2_to_0_address_term_bound_15) ).

fof(address_association_120,axiom,
    v4049_range_2_to_0_address_association(constB15,v4049_range_2_to_0_address_term_bound_15) ).

fof(address_false_msb_171,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_14,bitIndex4) ).

fof(address_false_msb_170,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_14,bitIndex3) ).

fof(transient_address_definition_119,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_14,bitIndex0)
    <=> v4049(constB14,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_14,bitIndex1)
    <=> v4049(constB14,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_14,bitIndex2)
    <=> v4049(constB14,bitIndex2) ) ) ).

fof(is_address_139,axiom,
    address(v4049_range_2_to_0_address_term_bound_14) ).

fof(address_association_119,axiom,
    v4049_range_2_to_0_address_association(constB14,v4049_range_2_to_0_address_term_bound_14) ).

fof(address_false_msb_169,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_13,bitIndex4) ).

fof(address_false_msb_168,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_13,bitIndex3) ).

fof(transient_address_definition_118,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_13,bitIndex0)
    <=> v4049(constB13,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_13,bitIndex1)
    <=> v4049(constB13,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_13,bitIndex2)
    <=> v4049(constB13,bitIndex2) ) ) ).

fof(is_address_138,axiom,
    address(v4049_range_2_to_0_address_term_bound_13) ).

fof(address_association_118,axiom,
    v4049_range_2_to_0_address_association(constB13,v4049_range_2_to_0_address_term_bound_13) ).

fof(address_false_msb_167,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_12,bitIndex4) ).

fof(address_false_msb_166,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_12,bitIndex3) ).

fof(transient_address_definition_117,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_12,bitIndex0)
    <=> v4049(constB12,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_12,bitIndex1)
    <=> v4049(constB12,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_12,bitIndex2)
    <=> v4049(constB12,bitIndex2) ) ) ).

fof(is_address_137,axiom,
    address(v4049_range_2_to_0_address_term_bound_12) ).

fof(address_association_117,axiom,
    v4049_range_2_to_0_address_association(constB12,v4049_range_2_to_0_address_term_bound_12) ).

fof(address_false_msb_165,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_11,bitIndex4) ).

fof(address_false_msb_164,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_11,bitIndex3) ).

fof(transient_address_definition_116,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_11,bitIndex0)
    <=> v4049(constB11,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_11,bitIndex1)
    <=> v4049(constB11,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_11,bitIndex2)
    <=> v4049(constB11,bitIndex2) ) ) ).

fof(is_address_136,axiom,
    address(v4049_range_2_to_0_address_term_bound_11) ).

fof(address_association_116,axiom,
    v4049_range_2_to_0_address_association(constB11,v4049_range_2_to_0_address_term_bound_11) ).

fof(address_false_msb_163,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_10,bitIndex4) ).

fof(address_false_msb_162,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_10,bitIndex3) ).

fof(transient_address_definition_115,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_10,bitIndex0)
    <=> v4049(constB10,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_10,bitIndex1)
    <=> v4049(constB10,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_10,bitIndex2)
    <=> v4049(constB10,bitIndex2) ) ) ).

fof(is_address_135,axiom,
    address(v4049_range_2_to_0_address_term_bound_10) ).

fof(address_association_115,axiom,
    v4049_range_2_to_0_address_association(constB10,v4049_range_2_to_0_address_term_bound_10) ).

fof(address_false_msb_161,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_9,bitIndex4) ).

fof(address_false_msb_160,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_9,bitIndex3) ).

fof(transient_address_definition_114,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_9,bitIndex0)
    <=> v4049(constB9,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_9,bitIndex1)
    <=> v4049(constB9,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_9,bitIndex2)
    <=> v4049(constB9,bitIndex2) ) ) ).

fof(is_address_134,axiom,
    address(v4049_range_2_to_0_address_term_bound_9) ).

fof(address_association_114,axiom,
    v4049_range_2_to_0_address_association(constB9,v4049_range_2_to_0_address_term_bound_9) ).

fof(address_false_msb_159,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_8,bitIndex4) ).

fof(address_false_msb_158,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_8,bitIndex3) ).

fof(transient_address_definition_113,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_8,bitIndex0)
    <=> v4049(constB8,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_8,bitIndex1)
    <=> v4049(constB8,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_8,bitIndex2)
    <=> v4049(constB8,bitIndex2) ) ) ).

fof(is_address_133,axiom,
    address(v4049_range_2_to_0_address_term_bound_8) ).

fof(address_association_113,axiom,
    v4049_range_2_to_0_address_association(constB8,v4049_range_2_to_0_address_term_bound_8) ).

fof(address_false_msb_157,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_7,bitIndex4) ).

fof(address_false_msb_156,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_7,bitIndex3) ).

fof(transient_address_definition_112,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_7,bitIndex0)
    <=> v4049(constB7,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_7,bitIndex1)
    <=> v4049(constB7,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_7,bitIndex2)
    <=> v4049(constB7,bitIndex2) ) ) ).

fof(is_address_132,axiom,
    address(v4049_range_2_to_0_address_term_bound_7) ).

fof(address_association_112,axiom,
    v4049_range_2_to_0_address_association(constB7,v4049_range_2_to_0_address_term_bound_7) ).

fof(address_false_msb_155,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_6,bitIndex4) ).

fof(address_false_msb_154,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_6,bitIndex3) ).

fof(transient_address_definition_111,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_6,bitIndex0)
    <=> v4049(constB6,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_6,bitIndex1)
    <=> v4049(constB6,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_6,bitIndex2)
    <=> v4049(constB6,bitIndex2) ) ) ).

fof(is_address_131,axiom,
    address(v4049_range_2_to_0_address_term_bound_6) ).

fof(address_association_111,axiom,
    v4049_range_2_to_0_address_association(constB6,v4049_range_2_to_0_address_term_bound_6) ).

fof(address_false_msb_153,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_5,bitIndex4) ).

fof(address_false_msb_152,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_5,bitIndex3) ).

fof(transient_address_definition_110,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_5,bitIndex0)
    <=> v4049(constB5,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_5,bitIndex1)
    <=> v4049(constB5,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_5,bitIndex2)
    <=> v4049(constB5,bitIndex2) ) ) ).

fof(is_address_130,axiom,
    address(v4049_range_2_to_0_address_term_bound_5) ).

fof(address_association_110,axiom,
    v4049_range_2_to_0_address_association(constB5,v4049_range_2_to_0_address_term_bound_5) ).

fof(address_false_msb_151,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_4,bitIndex4) ).

fof(address_false_msb_150,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_4,bitIndex3) ).

fof(transient_address_definition_109,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_4,bitIndex0)
    <=> v4049(constB4,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_4,bitIndex1)
    <=> v4049(constB4,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_4,bitIndex2)
    <=> v4049(constB4,bitIndex2) ) ) ).

fof(is_address_129,axiom,
    address(v4049_range_2_to_0_address_term_bound_4) ).

fof(address_association_109,axiom,
    v4049_range_2_to_0_address_association(constB4,v4049_range_2_to_0_address_term_bound_4) ).

fof(address_false_msb_149,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_3,bitIndex4) ).

fof(address_false_msb_148,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_3,bitIndex3) ).

fof(transient_address_definition_108,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_3,bitIndex0)
    <=> v4049(constB3,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_3,bitIndex1)
    <=> v4049(constB3,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_3,bitIndex2)
    <=> v4049(constB3,bitIndex2) ) ) ).

fof(is_address_128,axiom,
    address(v4049_range_2_to_0_address_term_bound_3) ).

fof(address_association_108,axiom,
    v4049_range_2_to_0_address_association(constB3,v4049_range_2_to_0_address_term_bound_3) ).

fof(address_false_msb_147,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_2,bitIndex4) ).

fof(address_false_msb_146,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_2,bitIndex3) ).

fof(transient_address_definition_107,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_2,bitIndex0)
    <=> v4049(constB2,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_2,bitIndex1)
    <=> v4049(constB2,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_2,bitIndex2)
    <=> v4049(constB2,bitIndex2) ) ) ).

fof(is_address_127,axiom,
    address(v4049_range_2_to_0_address_term_bound_2) ).

fof(address_association_107,axiom,
    v4049_range_2_to_0_address_association(constB2,v4049_range_2_to_0_address_term_bound_2) ).

fof(address_false_msb_145,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_1,bitIndex4) ).

fof(address_false_msb_144,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_1,bitIndex3) ).

fof(transient_address_definition_106,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_1,bitIndex0)
    <=> v4049(constB1,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_1,bitIndex1)
    <=> v4049(constB1,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_1,bitIndex2)
    <=> v4049(constB1,bitIndex2) ) ) ).

fof(is_address_126,axiom,
    address(v4049_range_2_to_0_address_term_bound_1) ).

fof(address_association_106,axiom,
    v4049_range_2_to_0_address_association(constB1,v4049_range_2_to_0_address_term_bound_1) ).

fof(address_false_msb_143,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_0,bitIndex4) ).

fof(address_false_msb_142,axiom,
    ~ addressVal(v4049_range_2_to_0_address_term_bound_0,bitIndex3) ).

fof(transient_address_definition_105,axiom,
    ( $true
    & ( addressVal(v4049_range_2_to_0_address_term_bound_0,bitIndex0)
    <=> v4049(constB0,bitIndex0) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_0,bitIndex1)
    <=> v4049(constB0,bitIndex1) )
    & ( addressVal(v4049_range_2_to_0_address_term_bound_0,bitIndex2)
    <=> v4049(constB0,bitIndex2) ) ) ).

fof(is_address_125,axiom,
    address(v4049_range_2_to_0_address_term_bound_0) ).

fof(address_association_105,axiom,
    v4049_range_2_to_0_address_association(constB0,v4049_range_2_to_0_address_term_bound_0) ).

fof(address_false_msb_141,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_20,bitIndex4) ).

fof(address_false_msb_140,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_20,bitIndex3) ).

fof(transient_address_definition_104,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_20,bitIndex0)
    <=> v4023(constB20,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_20,bitIndex1)
    <=> v4023(constB20,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_20,bitIndex2)
    <=> v4023(constB20,bitIndex2) ) ) ).

fof(is_address_124,axiom,
    address(v4023_range_2_to_0_address_term_bound_20) ).

fof(address_association_104,axiom,
    v4023_range_2_to_0_address_association(constB20,v4023_range_2_to_0_address_term_bound_20) ).

fof(address_false_msb_139,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_19,bitIndex4) ).

fof(address_false_msb_138,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_19,bitIndex3) ).

fof(transient_address_definition_103,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_19,bitIndex0)
    <=> v4023(constB19,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_19,bitIndex1)
    <=> v4023(constB19,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_19,bitIndex2)
    <=> v4023(constB19,bitIndex2) ) ) ).

fof(is_address_123,axiom,
    address(v4023_range_2_to_0_address_term_bound_19) ).

fof(address_association_103,axiom,
    v4023_range_2_to_0_address_association(constB19,v4023_range_2_to_0_address_term_bound_19) ).

fof(address_false_msb_137,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_18,bitIndex4) ).

fof(address_false_msb_136,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_18,bitIndex3) ).

fof(transient_address_definition_102,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_18,bitIndex0)
    <=> v4023(constB18,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_18,bitIndex1)
    <=> v4023(constB18,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_18,bitIndex2)
    <=> v4023(constB18,bitIndex2) ) ) ).

fof(is_address_122,axiom,
    address(v4023_range_2_to_0_address_term_bound_18) ).

fof(address_association_102,axiom,
    v4023_range_2_to_0_address_association(constB18,v4023_range_2_to_0_address_term_bound_18) ).

fof(address_false_msb_135,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_17,bitIndex4) ).

fof(address_false_msb_134,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_17,bitIndex3) ).

fof(transient_address_definition_101,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_17,bitIndex0)
    <=> v4023(constB17,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_17,bitIndex1)
    <=> v4023(constB17,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_17,bitIndex2)
    <=> v4023(constB17,bitIndex2) ) ) ).

fof(is_address_121,axiom,
    address(v4023_range_2_to_0_address_term_bound_17) ).

fof(address_association_101,axiom,
    v4023_range_2_to_0_address_association(constB17,v4023_range_2_to_0_address_term_bound_17) ).

fof(address_false_msb_133,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_16,bitIndex4) ).

fof(address_false_msb_132,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_16,bitIndex3) ).

fof(transient_address_definition_100,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_16,bitIndex0)
    <=> v4023(constB16,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_16,bitIndex1)
    <=> v4023(constB16,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_16,bitIndex2)
    <=> v4023(constB16,bitIndex2) ) ) ).

fof(is_address_120,axiom,
    address(v4023_range_2_to_0_address_term_bound_16) ).

fof(address_association_100,axiom,
    v4023_range_2_to_0_address_association(constB16,v4023_range_2_to_0_address_term_bound_16) ).

fof(address_false_msb_131,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_15,bitIndex4) ).

fof(address_false_msb_130,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_15,bitIndex3) ).

fof(transient_address_definition_99,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_15,bitIndex0)
    <=> v4023(constB15,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_15,bitIndex1)
    <=> v4023(constB15,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_15,bitIndex2)
    <=> v4023(constB15,bitIndex2) ) ) ).

fof(is_address_119,axiom,
    address(v4023_range_2_to_0_address_term_bound_15) ).

fof(address_association_99,axiom,
    v4023_range_2_to_0_address_association(constB15,v4023_range_2_to_0_address_term_bound_15) ).

fof(address_false_msb_129,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_14,bitIndex4) ).

fof(address_false_msb_128,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_14,bitIndex3) ).

fof(transient_address_definition_98,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_14,bitIndex0)
    <=> v4023(constB14,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_14,bitIndex1)
    <=> v4023(constB14,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_14,bitIndex2)
    <=> v4023(constB14,bitIndex2) ) ) ).

fof(is_address_118,axiom,
    address(v4023_range_2_to_0_address_term_bound_14) ).

fof(address_association_98,axiom,
    v4023_range_2_to_0_address_association(constB14,v4023_range_2_to_0_address_term_bound_14) ).

fof(address_false_msb_127,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_13,bitIndex4) ).

fof(address_false_msb_126,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_13,bitIndex3) ).

fof(transient_address_definition_97,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_13,bitIndex0)
    <=> v4023(constB13,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_13,bitIndex1)
    <=> v4023(constB13,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_13,bitIndex2)
    <=> v4023(constB13,bitIndex2) ) ) ).

fof(is_address_117,axiom,
    address(v4023_range_2_to_0_address_term_bound_13) ).

fof(address_association_97,axiom,
    v4023_range_2_to_0_address_association(constB13,v4023_range_2_to_0_address_term_bound_13) ).

fof(address_false_msb_125,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_12,bitIndex4) ).

fof(address_false_msb_124,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_12,bitIndex3) ).

fof(transient_address_definition_96,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_12,bitIndex0)
    <=> v4023(constB12,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_12,bitIndex1)
    <=> v4023(constB12,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_12,bitIndex2)
    <=> v4023(constB12,bitIndex2) ) ) ).

fof(is_address_116,axiom,
    address(v4023_range_2_to_0_address_term_bound_12) ).

fof(address_association_96,axiom,
    v4023_range_2_to_0_address_association(constB12,v4023_range_2_to_0_address_term_bound_12) ).

fof(address_false_msb_123,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_11,bitIndex4) ).

fof(address_false_msb_122,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_11,bitIndex3) ).

fof(transient_address_definition_95,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_11,bitIndex0)
    <=> v4023(constB11,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_11,bitIndex1)
    <=> v4023(constB11,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_11,bitIndex2)
    <=> v4023(constB11,bitIndex2) ) ) ).

fof(is_address_115,axiom,
    address(v4023_range_2_to_0_address_term_bound_11) ).

fof(address_association_95,axiom,
    v4023_range_2_to_0_address_association(constB11,v4023_range_2_to_0_address_term_bound_11) ).

fof(address_false_msb_121,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_10,bitIndex4) ).

fof(address_false_msb_120,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_10,bitIndex3) ).

fof(transient_address_definition_94,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_10,bitIndex0)
    <=> v4023(constB10,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_10,bitIndex1)
    <=> v4023(constB10,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_10,bitIndex2)
    <=> v4023(constB10,bitIndex2) ) ) ).

fof(is_address_114,axiom,
    address(v4023_range_2_to_0_address_term_bound_10) ).

fof(address_association_94,axiom,
    v4023_range_2_to_0_address_association(constB10,v4023_range_2_to_0_address_term_bound_10) ).

fof(address_false_msb_119,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_9,bitIndex4) ).

fof(address_false_msb_118,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_9,bitIndex3) ).

fof(transient_address_definition_93,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_9,bitIndex0)
    <=> v4023(constB9,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_9,bitIndex1)
    <=> v4023(constB9,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_9,bitIndex2)
    <=> v4023(constB9,bitIndex2) ) ) ).

fof(is_address_113,axiom,
    address(v4023_range_2_to_0_address_term_bound_9) ).

fof(address_association_93,axiom,
    v4023_range_2_to_0_address_association(constB9,v4023_range_2_to_0_address_term_bound_9) ).

fof(address_false_msb_117,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_8,bitIndex4) ).

fof(address_false_msb_116,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_8,bitIndex3) ).

fof(transient_address_definition_92,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_8,bitIndex0)
    <=> v4023(constB8,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_8,bitIndex1)
    <=> v4023(constB8,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_8,bitIndex2)
    <=> v4023(constB8,bitIndex2) ) ) ).

fof(is_address_112,axiom,
    address(v4023_range_2_to_0_address_term_bound_8) ).

fof(address_association_92,axiom,
    v4023_range_2_to_0_address_association(constB8,v4023_range_2_to_0_address_term_bound_8) ).

fof(address_false_msb_115,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_7,bitIndex4) ).

fof(address_false_msb_114,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_7,bitIndex3) ).

fof(transient_address_definition_91,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_7,bitIndex0)
    <=> v4023(constB7,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_7,bitIndex1)
    <=> v4023(constB7,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_7,bitIndex2)
    <=> v4023(constB7,bitIndex2) ) ) ).

fof(is_address_111,axiom,
    address(v4023_range_2_to_0_address_term_bound_7) ).

fof(address_association_91,axiom,
    v4023_range_2_to_0_address_association(constB7,v4023_range_2_to_0_address_term_bound_7) ).

fof(address_false_msb_113,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_6,bitIndex4) ).

fof(address_false_msb_112,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_6,bitIndex3) ).

fof(transient_address_definition_90,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_6,bitIndex0)
    <=> v4023(constB6,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_6,bitIndex1)
    <=> v4023(constB6,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_6,bitIndex2)
    <=> v4023(constB6,bitIndex2) ) ) ).

fof(is_address_110,axiom,
    address(v4023_range_2_to_0_address_term_bound_6) ).

fof(address_association_90,axiom,
    v4023_range_2_to_0_address_association(constB6,v4023_range_2_to_0_address_term_bound_6) ).

fof(address_false_msb_111,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_5,bitIndex4) ).

fof(address_false_msb_110,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_5,bitIndex3) ).

fof(transient_address_definition_89,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_5,bitIndex0)
    <=> v4023(constB5,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_5,bitIndex1)
    <=> v4023(constB5,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_5,bitIndex2)
    <=> v4023(constB5,bitIndex2) ) ) ).

fof(is_address_109,axiom,
    address(v4023_range_2_to_0_address_term_bound_5) ).

fof(address_association_89,axiom,
    v4023_range_2_to_0_address_association(constB5,v4023_range_2_to_0_address_term_bound_5) ).

fof(address_false_msb_109,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_4,bitIndex4) ).

fof(address_false_msb_108,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_4,bitIndex3) ).

fof(transient_address_definition_88,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_4,bitIndex0)
    <=> v4023(constB4,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_4,bitIndex1)
    <=> v4023(constB4,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_4,bitIndex2)
    <=> v4023(constB4,bitIndex2) ) ) ).

fof(is_address_108,axiom,
    address(v4023_range_2_to_0_address_term_bound_4) ).

fof(address_association_88,axiom,
    v4023_range_2_to_0_address_association(constB4,v4023_range_2_to_0_address_term_bound_4) ).

fof(address_false_msb_107,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_3,bitIndex4) ).

fof(address_false_msb_106,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_3,bitIndex3) ).

fof(transient_address_definition_87,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_3,bitIndex0)
    <=> v4023(constB3,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_3,bitIndex1)
    <=> v4023(constB3,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_3,bitIndex2)
    <=> v4023(constB3,bitIndex2) ) ) ).

fof(is_address_107,axiom,
    address(v4023_range_2_to_0_address_term_bound_3) ).

fof(address_association_87,axiom,
    v4023_range_2_to_0_address_association(constB3,v4023_range_2_to_0_address_term_bound_3) ).

fof(address_false_msb_105,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_2,bitIndex4) ).

fof(address_false_msb_104,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_2,bitIndex3) ).

fof(transient_address_definition_86,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_2,bitIndex0)
    <=> v4023(constB2,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_2,bitIndex1)
    <=> v4023(constB2,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_2,bitIndex2)
    <=> v4023(constB2,bitIndex2) ) ) ).

fof(is_address_106,axiom,
    address(v4023_range_2_to_0_address_term_bound_2) ).

fof(address_association_86,axiom,
    v4023_range_2_to_0_address_association(constB2,v4023_range_2_to_0_address_term_bound_2) ).

fof(address_false_msb_103,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_1,bitIndex4) ).

fof(address_false_msb_102,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_1,bitIndex3) ).

fof(transient_address_definition_85,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_1,bitIndex0)
    <=> v4023(constB1,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_1,bitIndex1)
    <=> v4023(constB1,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_1,bitIndex2)
    <=> v4023(constB1,bitIndex2) ) ) ).

fof(is_address_105,axiom,
    address(v4023_range_2_to_0_address_term_bound_1) ).

fof(address_association_85,axiom,
    v4023_range_2_to_0_address_association(constB1,v4023_range_2_to_0_address_term_bound_1) ).

fof(address_false_msb_101,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_0,bitIndex4) ).

fof(address_false_msb_100,axiom,
    ~ addressVal(v4023_range_2_to_0_address_term_bound_0,bitIndex3) ).

fof(transient_address_definition_84,axiom,
    ( $true
    & ( addressVal(v4023_range_2_to_0_address_term_bound_0,bitIndex0)
    <=> v4023(constB0,bitIndex0) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_0,bitIndex1)
    <=> v4023(constB0,bitIndex1) )
    & ( addressVal(v4023_range_2_to_0_address_term_bound_0,bitIndex2)
    <=> v4023(constB0,bitIndex2) ) ) ).

fof(is_address_104,axiom,
    address(v4023_range_2_to_0_address_term_bound_0) ).

fof(address_association_84,axiom,
    v4023_range_2_to_0_address_association(constB0,v4023_range_2_to_0_address_term_bound_0) ).

fof(is_address_103,axiom,
    address(b11111_address_term) ).

fof(constant_address_definition_19,axiom,
    ! [B] :
      ( addressVal(b11111_address_term,B)
    <=> b11111(B) ) ).

fof(address_false_msb_99,axiom,
    ~ addressVal(b1110_address_term,bitIndex4) ).

fof(is_address_102,axiom,
    address(b1110_address_term) ).

fof(constant_address_definition_18,axiom,
    ! [B] :
      ( addressVal(b1110_address_term,B)
    <=> b1110(B) ) ).

fof(address_false_msb_98,axiom,
    ~ addressVal(b1000_address_term,bitIndex4) ).

fof(is_address_101,axiom,
    address(b1000_address_term) ).

fof(constant_address_definition_17,axiom,
    ! [B] :
      ( addressVal(b1000_address_term,B)
    <=> b1000(B) ) ).

fof(address_false_msb_97,axiom,
    ~ addressVal(b0111_address_term,bitIndex4) ).

fof(is_address_100,axiom,
    address(b0111_address_term) ).

fof(constant_address_definition_16,axiom,
    ! [B] :
      ( addressVal(b0111_address_term,B)
    <=> b0111(B) ) ).

fof(address_false_msb_96,axiom,
    ~ addressVal(b1111_address_term,bitIndex4) ).

fof(is_address_99,axiom,
    address(b1111_address_term) ).

fof(constant_address_definition_15,axiom,
    ! [B] :
      ( addressVal(b1111_address_term,B)
    <=> b1111(B) ) ).

fof(address_false_msb_95,axiom,
    ~ addressVal(b1101_address_term,bitIndex4) ).

fof(is_address_98,axiom,
    address(b1101_address_term) ).

fof(constant_address_definition_14,axiom,
    ! [B] :
      ( addressVal(b1101_address_term,B)
    <=> b1101(B) ) ).

fof(address_false_msb_94,axiom,
    ~ addressVal(b1100_address_term,bitIndex4) ).

fof(is_address_97,axiom,
    address(b1100_address_term) ).

fof(constant_address_definition_13,axiom,
    ! [B] :
      ( addressVal(b1100_address_term,B)
    <=> b1100(B) ) ).

fof(address_false_msb_93,axiom,
    ~ addressVal(b1011_address_term,bitIndex4) ).

fof(is_address_96,axiom,
    address(b1011_address_term) ).

fof(constant_address_definition_12,axiom,
    ! [B] :
      ( addressVal(b1011_address_term,B)
    <=> b1011(B) ) ).

fof(address_false_msb_92,axiom,
    ~ addressVal(b1010_address_term,bitIndex4) ).

fof(is_address_95,axiom,
    address(b1010_address_term) ).

fof(constant_address_definition_11,axiom,
    ! [B] :
      ( addressVal(b1010_address_term,B)
    <=> b1010(B) ) ).

fof(address_false_msb_91,axiom,
    ~ addressVal(b1001_address_term,bitIndex4) ).

fof(is_address_94,axiom,
    address(b1001_address_term) ).

fof(constant_address_definition_10,axiom,
    ! [B] :
      ( addressVal(b1001_address_term,B)
    <=> b1001(B) ) ).

fof(address_false_msb_90,axiom,
    ~ addressVal(b0101_address_term,bitIndex4) ).

fof(is_address_93,axiom,
    address(b0101_address_term) ).

fof(constant_address_definition_9,axiom,
    ! [B] :
      ( addressVal(b0101_address_term,B)
    <=> b0101(B) ) ).

fof(address_false_msb_89,axiom,
    ~ addressVal(b0100_address_term,bitIndex4) ).

fof(is_address_92,axiom,
    address(b0100_address_term) ).

fof(constant_address_definition_8,axiom,
    ! [B] :
      ( addressVal(b0100_address_term,B)
    <=> b0100(B) ) ).

fof(address_false_msb_88,axiom,
    ~ addressVal(b0011_address_term,bitIndex4) ).

fof(is_address_91,axiom,
    address(b0011_address_term) ).

fof(constant_address_definition_7,axiom,
    ! [B] :
      ( addressVal(b0011_address_term,B)
    <=> b0011(B) ) ).

fof(address_false_msb_87,axiom,
    ~ addressVal(b0010_address_term,bitIndex4) ).

fof(is_address_90,axiom,
    address(b0010_address_term) ).

fof(constant_address_definition_6,axiom,
    ! [B] :
      ( addressVal(b0010_address_term,B)
    <=> b0010(B) ) ).

fof(address_false_msb_86,axiom,
    ~ addressVal(b0001_address_term,bitIndex4) ).

fof(is_address_89,axiom,
    address(b0001_address_term) ).

fof(constant_address_definition_5,axiom,
    ! [B] :
      ( addressVal(b0001_address_term,B)
    <=> b0001(B) ) ).

fof(address_false_msb_85,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_20,bitIndex4) ).

fof(transient_address_definition_83,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_20,bitIndex0)
    <=> v600(constB20,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_20,bitIndex1)
    <=> v600(constB20,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_20,bitIndex2)
    <=> v600(constB20,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_20,bitIndex3)
    <=> v600(constB20,bitIndex3) ) ) ).

fof(is_address_88,axiom,
    address(v600_range_3_to_0_address_term_bound_20) ).

fof(address_association_83,axiom,
    v600_range_3_to_0_address_association(constB20,v600_range_3_to_0_address_term_bound_20) ).

fof(address_false_msb_84,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_19,bitIndex4) ).

fof(transient_address_definition_82,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_19,bitIndex0)
    <=> v600(constB19,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_19,bitIndex1)
    <=> v600(constB19,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_19,bitIndex2)
    <=> v600(constB19,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_19,bitIndex3)
    <=> v600(constB19,bitIndex3) ) ) ).

fof(is_address_87,axiom,
    address(v600_range_3_to_0_address_term_bound_19) ).

fof(address_association_82,axiom,
    v600_range_3_to_0_address_association(constB19,v600_range_3_to_0_address_term_bound_19) ).

fof(address_false_msb_83,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_18,bitIndex4) ).

fof(transient_address_definition_81,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_18,bitIndex0)
    <=> v600(constB18,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_18,bitIndex1)
    <=> v600(constB18,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_18,bitIndex2)
    <=> v600(constB18,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_18,bitIndex3)
    <=> v600(constB18,bitIndex3) ) ) ).

fof(is_address_86,axiom,
    address(v600_range_3_to_0_address_term_bound_18) ).

fof(address_association_81,axiom,
    v600_range_3_to_0_address_association(constB18,v600_range_3_to_0_address_term_bound_18) ).

fof(address_false_msb_82,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_17,bitIndex4) ).

fof(transient_address_definition_80,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_17,bitIndex0)
    <=> v600(constB17,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_17,bitIndex1)
    <=> v600(constB17,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_17,bitIndex2)
    <=> v600(constB17,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_17,bitIndex3)
    <=> v600(constB17,bitIndex3) ) ) ).

fof(is_address_85,axiom,
    address(v600_range_3_to_0_address_term_bound_17) ).

fof(address_association_80,axiom,
    v600_range_3_to_0_address_association(constB17,v600_range_3_to_0_address_term_bound_17) ).

fof(address_false_msb_81,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_16,bitIndex4) ).

fof(transient_address_definition_79,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_16,bitIndex0)
    <=> v600(constB16,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_16,bitIndex1)
    <=> v600(constB16,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_16,bitIndex2)
    <=> v600(constB16,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_16,bitIndex3)
    <=> v600(constB16,bitIndex3) ) ) ).

fof(is_address_84,axiom,
    address(v600_range_3_to_0_address_term_bound_16) ).

fof(address_association_79,axiom,
    v600_range_3_to_0_address_association(constB16,v600_range_3_to_0_address_term_bound_16) ).

fof(address_false_msb_80,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_15,bitIndex4) ).

fof(transient_address_definition_78,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_15,bitIndex0)
    <=> v600(constB15,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_15,bitIndex1)
    <=> v600(constB15,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_15,bitIndex2)
    <=> v600(constB15,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_15,bitIndex3)
    <=> v600(constB15,bitIndex3) ) ) ).

fof(is_address_83,axiom,
    address(v600_range_3_to_0_address_term_bound_15) ).

fof(address_association_78,axiom,
    v600_range_3_to_0_address_association(constB15,v600_range_3_to_0_address_term_bound_15) ).

fof(address_false_msb_79,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_14,bitIndex4) ).

fof(transient_address_definition_77,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_14,bitIndex0)
    <=> v600(constB14,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_14,bitIndex1)
    <=> v600(constB14,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_14,bitIndex2)
    <=> v600(constB14,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_14,bitIndex3)
    <=> v600(constB14,bitIndex3) ) ) ).

fof(is_address_82,axiom,
    address(v600_range_3_to_0_address_term_bound_14) ).

fof(address_association_77,axiom,
    v600_range_3_to_0_address_association(constB14,v600_range_3_to_0_address_term_bound_14) ).

fof(address_false_msb_78,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_13,bitIndex4) ).

fof(transient_address_definition_76,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_13,bitIndex0)
    <=> v600(constB13,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_13,bitIndex1)
    <=> v600(constB13,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_13,bitIndex2)
    <=> v600(constB13,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_13,bitIndex3)
    <=> v600(constB13,bitIndex3) ) ) ).

fof(is_address_81,axiom,
    address(v600_range_3_to_0_address_term_bound_13) ).

fof(address_association_76,axiom,
    v600_range_3_to_0_address_association(constB13,v600_range_3_to_0_address_term_bound_13) ).

fof(address_false_msb_77,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_12,bitIndex4) ).

fof(transient_address_definition_75,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_12,bitIndex0)
    <=> v600(constB12,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_12,bitIndex1)
    <=> v600(constB12,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_12,bitIndex2)
    <=> v600(constB12,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_12,bitIndex3)
    <=> v600(constB12,bitIndex3) ) ) ).

fof(is_address_80,axiom,
    address(v600_range_3_to_0_address_term_bound_12) ).

fof(address_association_75,axiom,
    v600_range_3_to_0_address_association(constB12,v600_range_3_to_0_address_term_bound_12) ).

fof(address_false_msb_76,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_11,bitIndex4) ).

fof(transient_address_definition_74,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_11,bitIndex0)
    <=> v600(constB11,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_11,bitIndex1)
    <=> v600(constB11,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_11,bitIndex2)
    <=> v600(constB11,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_11,bitIndex3)
    <=> v600(constB11,bitIndex3) ) ) ).

fof(is_address_79,axiom,
    address(v600_range_3_to_0_address_term_bound_11) ).

fof(address_association_74,axiom,
    v600_range_3_to_0_address_association(constB11,v600_range_3_to_0_address_term_bound_11) ).

fof(address_false_msb_75,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_10,bitIndex4) ).

fof(transient_address_definition_73,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_10,bitIndex0)
    <=> v600(constB10,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_10,bitIndex1)
    <=> v600(constB10,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_10,bitIndex2)
    <=> v600(constB10,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_10,bitIndex3)
    <=> v600(constB10,bitIndex3) ) ) ).

fof(is_address_78,axiom,
    address(v600_range_3_to_0_address_term_bound_10) ).

fof(address_association_73,axiom,
    v600_range_3_to_0_address_association(constB10,v600_range_3_to_0_address_term_bound_10) ).

fof(address_false_msb_74,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_9,bitIndex4) ).

fof(transient_address_definition_72,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_9,bitIndex0)
    <=> v600(constB9,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_9,bitIndex1)
    <=> v600(constB9,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_9,bitIndex2)
    <=> v600(constB9,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_9,bitIndex3)
    <=> v600(constB9,bitIndex3) ) ) ).

fof(is_address_77,axiom,
    address(v600_range_3_to_0_address_term_bound_9) ).

fof(address_association_72,axiom,
    v600_range_3_to_0_address_association(constB9,v600_range_3_to_0_address_term_bound_9) ).

fof(address_false_msb_73,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_8,bitIndex4) ).

fof(transient_address_definition_71,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_8,bitIndex0)
    <=> v600(constB8,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_8,bitIndex1)
    <=> v600(constB8,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_8,bitIndex2)
    <=> v600(constB8,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_8,bitIndex3)
    <=> v600(constB8,bitIndex3) ) ) ).

fof(is_address_76,axiom,
    address(v600_range_3_to_0_address_term_bound_8) ).

fof(address_association_71,axiom,
    v600_range_3_to_0_address_association(constB8,v600_range_3_to_0_address_term_bound_8) ).

fof(address_false_msb_72,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_7,bitIndex4) ).

fof(transient_address_definition_70,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_7,bitIndex0)
    <=> v600(constB7,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_7,bitIndex1)
    <=> v600(constB7,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_7,bitIndex2)
    <=> v600(constB7,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_7,bitIndex3)
    <=> v600(constB7,bitIndex3) ) ) ).

fof(is_address_75,axiom,
    address(v600_range_3_to_0_address_term_bound_7) ).

fof(address_association_70,axiom,
    v600_range_3_to_0_address_association(constB7,v600_range_3_to_0_address_term_bound_7) ).

fof(address_false_msb_71,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_6,bitIndex4) ).

fof(transient_address_definition_69,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_6,bitIndex0)
    <=> v600(constB6,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_6,bitIndex1)
    <=> v600(constB6,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_6,bitIndex2)
    <=> v600(constB6,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_6,bitIndex3)
    <=> v600(constB6,bitIndex3) ) ) ).

fof(is_address_74,axiom,
    address(v600_range_3_to_0_address_term_bound_6) ).

fof(address_association_69,axiom,
    v600_range_3_to_0_address_association(constB6,v600_range_3_to_0_address_term_bound_6) ).

fof(address_false_msb_70,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_5,bitIndex4) ).

fof(transient_address_definition_68,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_5,bitIndex0)
    <=> v600(constB5,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_5,bitIndex1)
    <=> v600(constB5,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_5,bitIndex2)
    <=> v600(constB5,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_5,bitIndex3)
    <=> v600(constB5,bitIndex3) ) ) ).

fof(is_address_73,axiom,
    address(v600_range_3_to_0_address_term_bound_5) ).

fof(address_association_68,axiom,
    v600_range_3_to_0_address_association(constB5,v600_range_3_to_0_address_term_bound_5) ).

fof(address_false_msb_69,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_4,bitIndex4) ).

fof(transient_address_definition_67,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_4,bitIndex0)
    <=> v600(constB4,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_4,bitIndex1)
    <=> v600(constB4,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_4,bitIndex2)
    <=> v600(constB4,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_4,bitIndex3)
    <=> v600(constB4,bitIndex3) ) ) ).

fof(is_address_72,axiom,
    address(v600_range_3_to_0_address_term_bound_4) ).

fof(address_association_67,axiom,
    v600_range_3_to_0_address_association(constB4,v600_range_3_to_0_address_term_bound_4) ).

fof(address_false_msb_68,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_3,bitIndex4) ).

fof(transient_address_definition_66,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_3,bitIndex0)
    <=> v600(constB3,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_3,bitIndex1)
    <=> v600(constB3,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_3,bitIndex2)
    <=> v600(constB3,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_3,bitIndex3)
    <=> v600(constB3,bitIndex3) ) ) ).

fof(is_address_71,axiom,
    address(v600_range_3_to_0_address_term_bound_3) ).

fof(address_association_66,axiom,
    v600_range_3_to_0_address_association(constB3,v600_range_3_to_0_address_term_bound_3) ).

fof(address_false_msb_67,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_2,bitIndex4) ).

fof(transient_address_definition_65,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_2,bitIndex0)
    <=> v600(constB2,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_2,bitIndex1)
    <=> v600(constB2,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_2,bitIndex2)
    <=> v600(constB2,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_2,bitIndex3)
    <=> v600(constB2,bitIndex3) ) ) ).

fof(is_address_70,axiom,
    address(v600_range_3_to_0_address_term_bound_2) ).

fof(address_association_65,axiom,
    v600_range_3_to_0_address_association(constB2,v600_range_3_to_0_address_term_bound_2) ).

fof(address_false_msb_66,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_1,bitIndex4) ).

fof(transient_address_definition_64,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_1,bitIndex0)
    <=> v600(constB1,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_1,bitIndex1)
    <=> v600(constB1,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_1,bitIndex2)
    <=> v600(constB1,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_1,bitIndex3)
    <=> v600(constB1,bitIndex3) ) ) ).

fof(is_address_69,axiom,
    address(v600_range_3_to_0_address_term_bound_1) ).

fof(address_association_64,axiom,
    v600_range_3_to_0_address_association(constB1,v600_range_3_to_0_address_term_bound_1) ).

fof(address_false_msb_65,axiom,
    ~ addressVal(v600_range_3_to_0_address_term_bound_0,bitIndex4) ).

fof(transient_address_definition_63,axiom,
    ( $true
    & ( addressVal(v600_range_3_to_0_address_term_bound_0,bitIndex0)
    <=> v600(constB0,bitIndex0) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_0,bitIndex1)
    <=> v600(constB0,bitIndex1) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_0,bitIndex2)
    <=> v600(constB0,bitIndex2) )
    & ( addressVal(v600_range_3_to_0_address_term_bound_0,bitIndex3)
    <=> v600(constB0,bitIndex3) ) ) ).

fof(is_address_68,axiom,
    address(v600_range_3_to_0_address_term_bound_0) ).

fof(address_association_63,axiom,
    v600_range_3_to_0_address_association(constB0,v600_range_3_to_0_address_term_bound_0) ).

fof(address_false_msb_64,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_20,bitIndex4) ).

fof(transient_address_definition_62,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_20,bitIndex0)
    <=> v572(constB20,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_20,bitIndex1)
    <=> v572(constB20,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_20,bitIndex2)
    <=> v572(constB20,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_20,bitIndex3)
    <=> v572(constB20,bitIndex3) ) ) ).

fof(is_address_67,axiom,
    address(v572_range_3_to_0_address_term_bound_20) ).

fof(address_association_62,axiom,
    v572_range_3_to_0_address_association(constB20,v572_range_3_to_0_address_term_bound_20) ).

fof(address_false_msb_63,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_19,bitIndex4) ).

fof(transient_address_definition_61,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_19,bitIndex0)
    <=> v572(constB19,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_19,bitIndex1)
    <=> v572(constB19,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_19,bitIndex2)
    <=> v572(constB19,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_19,bitIndex3)
    <=> v572(constB19,bitIndex3) ) ) ).

fof(is_address_66,axiom,
    address(v572_range_3_to_0_address_term_bound_19) ).

fof(address_association_61,axiom,
    v572_range_3_to_0_address_association(constB19,v572_range_3_to_0_address_term_bound_19) ).

fof(address_false_msb_62,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_18,bitIndex4) ).

fof(transient_address_definition_60,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_18,bitIndex0)
    <=> v572(constB18,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_18,bitIndex1)
    <=> v572(constB18,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_18,bitIndex2)
    <=> v572(constB18,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_18,bitIndex3)
    <=> v572(constB18,bitIndex3) ) ) ).

fof(is_address_65,axiom,
    address(v572_range_3_to_0_address_term_bound_18) ).

fof(address_association_60,axiom,
    v572_range_3_to_0_address_association(constB18,v572_range_3_to_0_address_term_bound_18) ).

fof(address_false_msb_61,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_17,bitIndex4) ).

fof(transient_address_definition_59,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_17,bitIndex0)
    <=> v572(constB17,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_17,bitIndex1)
    <=> v572(constB17,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_17,bitIndex2)
    <=> v572(constB17,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_17,bitIndex3)
    <=> v572(constB17,bitIndex3) ) ) ).

fof(is_address_64,axiom,
    address(v572_range_3_to_0_address_term_bound_17) ).

fof(address_association_59,axiom,
    v572_range_3_to_0_address_association(constB17,v572_range_3_to_0_address_term_bound_17) ).

fof(address_false_msb_60,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_16,bitIndex4) ).

fof(transient_address_definition_58,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_16,bitIndex0)
    <=> v572(constB16,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_16,bitIndex1)
    <=> v572(constB16,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_16,bitIndex2)
    <=> v572(constB16,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_16,bitIndex3)
    <=> v572(constB16,bitIndex3) ) ) ).

fof(is_address_63,axiom,
    address(v572_range_3_to_0_address_term_bound_16) ).

fof(address_association_58,axiom,
    v572_range_3_to_0_address_association(constB16,v572_range_3_to_0_address_term_bound_16) ).

fof(address_false_msb_59,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_15,bitIndex4) ).

fof(transient_address_definition_57,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_15,bitIndex0)
    <=> v572(constB15,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_15,bitIndex1)
    <=> v572(constB15,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_15,bitIndex2)
    <=> v572(constB15,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_15,bitIndex3)
    <=> v572(constB15,bitIndex3) ) ) ).

fof(is_address_62,axiom,
    address(v572_range_3_to_0_address_term_bound_15) ).

fof(address_association_57,axiom,
    v572_range_3_to_0_address_association(constB15,v572_range_3_to_0_address_term_bound_15) ).

fof(address_false_msb_58,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_14,bitIndex4) ).

fof(transient_address_definition_56,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_14,bitIndex0)
    <=> v572(constB14,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_14,bitIndex1)
    <=> v572(constB14,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_14,bitIndex2)
    <=> v572(constB14,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_14,bitIndex3)
    <=> v572(constB14,bitIndex3) ) ) ).

fof(is_address_61,axiom,
    address(v572_range_3_to_0_address_term_bound_14) ).

fof(address_association_56,axiom,
    v572_range_3_to_0_address_association(constB14,v572_range_3_to_0_address_term_bound_14) ).

fof(address_false_msb_57,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_13,bitIndex4) ).

fof(transient_address_definition_55,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_13,bitIndex0)
    <=> v572(constB13,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_13,bitIndex1)
    <=> v572(constB13,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_13,bitIndex2)
    <=> v572(constB13,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_13,bitIndex3)
    <=> v572(constB13,bitIndex3) ) ) ).

fof(is_address_60,axiom,
    address(v572_range_3_to_0_address_term_bound_13) ).

fof(address_association_55,axiom,
    v572_range_3_to_0_address_association(constB13,v572_range_3_to_0_address_term_bound_13) ).

fof(address_false_msb_56,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_12,bitIndex4) ).

fof(transient_address_definition_54,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_12,bitIndex0)
    <=> v572(constB12,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_12,bitIndex1)
    <=> v572(constB12,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_12,bitIndex2)
    <=> v572(constB12,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_12,bitIndex3)
    <=> v572(constB12,bitIndex3) ) ) ).

fof(is_address_59,axiom,
    address(v572_range_3_to_0_address_term_bound_12) ).

fof(address_association_54,axiom,
    v572_range_3_to_0_address_association(constB12,v572_range_3_to_0_address_term_bound_12) ).

fof(address_false_msb_55,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_11,bitIndex4) ).

fof(transient_address_definition_53,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_11,bitIndex0)
    <=> v572(constB11,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_11,bitIndex1)
    <=> v572(constB11,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_11,bitIndex2)
    <=> v572(constB11,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_11,bitIndex3)
    <=> v572(constB11,bitIndex3) ) ) ).

fof(is_address_58,axiom,
    address(v572_range_3_to_0_address_term_bound_11) ).

fof(address_association_53,axiom,
    v572_range_3_to_0_address_association(constB11,v572_range_3_to_0_address_term_bound_11) ).

fof(address_false_msb_54,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_10,bitIndex4) ).

fof(transient_address_definition_52,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_10,bitIndex0)
    <=> v572(constB10,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_10,bitIndex1)
    <=> v572(constB10,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_10,bitIndex2)
    <=> v572(constB10,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_10,bitIndex3)
    <=> v572(constB10,bitIndex3) ) ) ).

fof(is_address_57,axiom,
    address(v572_range_3_to_0_address_term_bound_10) ).

fof(address_association_52,axiom,
    v572_range_3_to_0_address_association(constB10,v572_range_3_to_0_address_term_bound_10) ).

fof(address_false_msb_53,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_9,bitIndex4) ).

fof(transient_address_definition_51,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_9,bitIndex0)
    <=> v572(constB9,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_9,bitIndex1)
    <=> v572(constB9,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_9,bitIndex2)
    <=> v572(constB9,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_9,bitIndex3)
    <=> v572(constB9,bitIndex3) ) ) ).

fof(is_address_56,axiom,
    address(v572_range_3_to_0_address_term_bound_9) ).

fof(address_association_51,axiom,
    v572_range_3_to_0_address_association(constB9,v572_range_3_to_0_address_term_bound_9) ).

fof(address_false_msb_52,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_8,bitIndex4) ).

fof(transient_address_definition_50,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_8,bitIndex0)
    <=> v572(constB8,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_8,bitIndex1)
    <=> v572(constB8,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_8,bitIndex2)
    <=> v572(constB8,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_8,bitIndex3)
    <=> v572(constB8,bitIndex3) ) ) ).

fof(is_address_55,axiom,
    address(v572_range_3_to_0_address_term_bound_8) ).

fof(address_association_50,axiom,
    v572_range_3_to_0_address_association(constB8,v572_range_3_to_0_address_term_bound_8) ).

fof(address_false_msb_51,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_7,bitIndex4) ).

fof(transient_address_definition_49,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_7,bitIndex0)
    <=> v572(constB7,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_7,bitIndex1)
    <=> v572(constB7,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_7,bitIndex2)
    <=> v572(constB7,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_7,bitIndex3)
    <=> v572(constB7,bitIndex3) ) ) ).

fof(is_address_54,axiom,
    address(v572_range_3_to_0_address_term_bound_7) ).

fof(address_association_49,axiom,
    v572_range_3_to_0_address_association(constB7,v572_range_3_to_0_address_term_bound_7) ).

fof(address_false_msb_50,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_6,bitIndex4) ).

fof(transient_address_definition_48,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_6,bitIndex0)
    <=> v572(constB6,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_6,bitIndex1)
    <=> v572(constB6,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_6,bitIndex2)
    <=> v572(constB6,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_6,bitIndex3)
    <=> v572(constB6,bitIndex3) ) ) ).

fof(is_address_53,axiom,
    address(v572_range_3_to_0_address_term_bound_6) ).

fof(address_association_48,axiom,
    v572_range_3_to_0_address_association(constB6,v572_range_3_to_0_address_term_bound_6) ).

fof(address_false_msb_49,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_5,bitIndex4) ).

fof(transient_address_definition_47,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_5,bitIndex0)
    <=> v572(constB5,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_5,bitIndex1)
    <=> v572(constB5,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_5,bitIndex2)
    <=> v572(constB5,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_5,bitIndex3)
    <=> v572(constB5,bitIndex3) ) ) ).

fof(is_address_52,axiom,
    address(v572_range_3_to_0_address_term_bound_5) ).

fof(address_association_47,axiom,
    v572_range_3_to_0_address_association(constB5,v572_range_3_to_0_address_term_bound_5) ).

fof(address_false_msb_48,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_4,bitIndex4) ).

fof(transient_address_definition_46,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_4,bitIndex0)
    <=> v572(constB4,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_4,bitIndex1)
    <=> v572(constB4,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_4,bitIndex2)
    <=> v572(constB4,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_4,bitIndex3)
    <=> v572(constB4,bitIndex3) ) ) ).

fof(is_address_51,axiom,
    address(v572_range_3_to_0_address_term_bound_4) ).

fof(address_association_46,axiom,
    v572_range_3_to_0_address_association(constB4,v572_range_3_to_0_address_term_bound_4) ).

fof(address_false_msb_47,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_3,bitIndex4) ).

fof(transient_address_definition_45,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_3,bitIndex0)
    <=> v572(constB3,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_3,bitIndex1)
    <=> v572(constB3,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_3,bitIndex2)
    <=> v572(constB3,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_3,bitIndex3)
    <=> v572(constB3,bitIndex3) ) ) ).

fof(is_address_50,axiom,
    address(v572_range_3_to_0_address_term_bound_3) ).

fof(address_association_45,axiom,
    v572_range_3_to_0_address_association(constB3,v572_range_3_to_0_address_term_bound_3) ).

fof(address_false_msb_46,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_2,bitIndex4) ).

fof(transient_address_definition_44,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_2,bitIndex0)
    <=> v572(constB2,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_2,bitIndex1)
    <=> v572(constB2,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_2,bitIndex2)
    <=> v572(constB2,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_2,bitIndex3)
    <=> v572(constB2,bitIndex3) ) ) ).

fof(is_address_49,axiom,
    address(v572_range_3_to_0_address_term_bound_2) ).

fof(address_association_44,axiom,
    v572_range_3_to_0_address_association(constB2,v572_range_3_to_0_address_term_bound_2) ).

fof(address_false_msb_45,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_1,bitIndex4) ).

fof(transient_address_definition_43,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_1,bitIndex0)
    <=> v572(constB1,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_1,bitIndex1)
    <=> v572(constB1,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_1,bitIndex2)
    <=> v572(constB1,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_1,bitIndex3)
    <=> v572(constB1,bitIndex3) ) ) ).

fof(is_address_48,axiom,
    address(v572_range_3_to_0_address_term_bound_1) ).

fof(address_association_43,axiom,
    v572_range_3_to_0_address_association(constB1,v572_range_3_to_0_address_term_bound_1) ).

fof(address_false_msb_44,axiom,
    ~ addressVal(v572_range_3_to_0_address_term_bound_0,bitIndex4) ).

fof(transient_address_definition_42,axiom,
    ( $true
    & ( addressVal(v572_range_3_to_0_address_term_bound_0,bitIndex0)
    <=> v572(constB0,bitIndex0) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_0,bitIndex1)
    <=> v572(constB0,bitIndex1) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_0,bitIndex2)
    <=> v572(constB0,bitIndex2) )
    & ( addressVal(v572_range_3_to_0_address_term_bound_0,bitIndex3)
    <=> v572(constB0,bitIndex3) ) ) ).

fof(is_address_47,axiom,
    address(v572_range_3_to_0_address_term_bound_0) ).

fof(address_association_42,axiom,
    v572_range_3_to_0_address_association(constB0,v572_range_3_to_0_address_term_bound_0) ).

fof(address_false_msb_43,axiom,
    ~ addressVal(b0110_address_term,bitIndex4) ).

fof(is_address_46,axiom,
    address(b0110_address_term) ).

fof(constant_address_definition_4,axiom,
    ! [B] :
      ( addressVal(b0110_address_term,B)
    <=> b0110(B) ) ).

fof(is_address_45,axiom,
    address(b00001_address_term) ).

fof(constant_address_definition_3,axiom,
    ! [B] :
      ( addressVal(b00001_address_term,B)
    <=> b00001(B) ) ).

fof(is_address_44,axiom,
    address(b10000_address_term) ).

fof(constant_address_definition_2,axiom,
    ! [B] :
      ( addressVal(b10000_address_term,B)
    <=> b10000(B) ) ).

fof(is_address_43,axiom,
    address(b00000_address_term) ).

fof(constant_address_definition_1,axiom,
    ! [B] :
      ( addressVal(b00000_address_term,B)
    <=> b00000(B) ) ).

fof(address_false_msb_42,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_20,bitIndex4) ).

fof(transient_address_definition_41,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_20,bitIndex0)
    <=> v361(constB20,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_20,bitIndex1)
    <=> v361(constB20,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_20,bitIndex2)
    <=> v361(constB20,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_20,bitIndex3)
    <=> v361(constB20,bitIndex3) ) ) ).

fof(is_address_42,axiom,
    address(v361_range_3_to_0_address_term_bound_20) ).

fof(address_association_41,axiom,
    v361_range_3_to_0_address_association(constB20,v361_range_3_to_0_address_term_bound_20) ).

fof(address_false_msb_41,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_19,bitIndex4) ).

fof(transient_address_definition_40,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_19,bitIndex0)
    <=> v361(constB19,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_19,bitIndex1)
    <=> v361(constB19,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_19,bitIndex2)
    <=> v361(constB19,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_19,bitIndex3)
    <=> v361(constB19,bitIndex3) ) ) ).

fof(is_address_41,axiom,
    address(v361_range_3_to_0_address_term_bound_19) ).

fof(address_association_40,axiom,
    v361_range_3_to_0_address_association(constB19,v361_range_3_to_0_address_term_bound_19) ).

fof(address_false_msb_40,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_18,bitIndex4) ).

fof(transient_address_definition_39,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_18,bitIndex0)
    <=> v361(constB18,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_18,bitIndex1)
    <=> v361(constB18,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_18,bitIndex2)
    <=> v361(constB18,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_18,bitIndex3)
    <=> v361(constB18,bitIndex3) ) ) ).

fof(is_address_40,axiom,
    address(v361_range_3_to_0_address_term_bound_18) ).

fof(address_association_39,axiom,
    v361_range_3_to_0_address_association(constB18,v361_range_3_to_0_address_term_bound_18) ).

fof(address_false_msb_39,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_17,bitIndex4) ).

fof(transient_address_definition_38,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_17,bitIndex0)
    <=> v361(constB17,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_17,bitIndex1)
    <=> v361(constB17,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_17,bitIndex2)
    <=> v361(constB17,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_17,bitIndex3)
    <=> v361(constB17,bitIndex3) ) ) ).

fof(is_address_39,axiom,
    address(v361_range_3_to_0_address_term_bound_17) ).

fof(address_association_38,axiom,
    v361_range_3_to_0_address_association(constB17,v361_range_3_to_0_address_term_bound_17) ).

fof(address_false_msb_38,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_16,bitIndex4) ).

fof(transient_address_definition_37,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_16,bitIndex0)
    <=> v361(constB16,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_16,bitIndex1)
    <=> v361(constB16,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_16,bitIndex2)
    <=> v361(constB16,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_16,bitIndex3)
    <=> v361(constB16,bitIndex3) ) ) ).

fof(is_address_38,axiom,
    address(v361_range_3_to_0_address_term_bound_16) ).

fof(address_association_37,axiom,
    v361_range_3_to_0_address_association(constB16,v361_range_3_to_0_address_term_bound_16) ).

fof(address_false_msb_37,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_15,bitIndex4) ).

fof(transient_address_definition_36,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_15,bitIndex0)
    <=> v361(constB15,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_15,bitIndex1)
    <=> v361(constB15,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_15,bitIndex2)
    <=> v361(constB15,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_15,bitIndex3)
    <=> v361(constB15,bitIndex3) ) ) ).

fof(is_address_37,axiom,
    address(v361_range_3_to_0_address_term_bound_15) ).

fof(address_association_36,axiom,
    v361_range_3_to_0_address_association(constB15,v361_range_3_to_0_address_term_bound_15) ).

fof(address_false_msb_36,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_14,bitIndex4) ).

fof(transient_address_definition_35,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_14,bitIndex0)
    <=> v361(constB14,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_14,bitIndex1)
    <=> v361(constB14,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_14,bitIndex2)
    <=> v361(constB14,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_14,bitIndex3)
    <=> v361(constB14,bitIndex3) ) ) ).

fof(is_address_36,axiom,
    address(v361_range_3_to_0_address_term_bound_14) ).

fof(address_association_35,axiom,
    v361_range_3_to_0_address_association(constB14,v361_range_3_to_0_address_term_bound_14) ).

fof(address_false_msb_35,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_13,bitIndex4) ).

fof(transient_address_definition_34,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_13,bitIndex0)
    <=> v361(constB13,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_13,bitIndex1)
    <=> v361(constB13,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_13,bitIndex2)
    <=> v361(constB13,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_13,bitIndex3)
    <=> v361(constB13,bitIndex3) ) ) ).

fof(is_address_35,axiom,
    address(v361_range_3_to_0_address_term_bound_13) ).

fof(address_association_34,axiom,
    v361_range_3_to_0_address_association(constB13,v361_range_3_to_0_address_term_bound_13) ).

fof(address_false_msb_34,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_12,bitIndex4) ).

fof(transient_address_definition_33,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_12,bitIndex0)
    <=> v361(constB12,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_12,bitIndex1)
    <=> v361(constB12,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_12,bitIndex2)
    <=> v361(constB12,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_12,bitIndex3)
    <=> v361(constB12,bitIndex3) ) ) ).

fof(is_address_34,axiom,
    address(v361_range_3_to_0_address_term_bound_12) ).

fof(address_association_33,axiom,
    v361_range_3_to_0_address_association(constB12,v361_range_3_to_0_address_term_bound_12) ).

fof(address_false_msb_33,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_11,bitIndex4) ).

fof(transient_address_definition_32,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_11,bitIndex0)
    <=> v361(constB11,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_11,bitIndex1)
    <=> v361(constB11,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_11,bitIndex2)
    <=> v361(constB11,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_11,bitIndex3)
    <=> v361(constB11,bitIndex3) ) ) ).

fof(is_address_33,axiom,
    address(v361_range_3_to_0_address_term_bound_11) ).

fof(address_association_32,axiom,
    v361_range_3_to_0_address_association(constB11,v361_range_3_to_0_address_term_bound_11) ).

fof(address_false_msb_32,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_10,bitIndex4) ).

fof(transient_address_definition_31,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_10,bitIndex0)
    <=> v361(constB10,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_10,bitIndex1)
    <=> v361(constB10,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_10,bitIndex2)
    <=> v361(constB10,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_10,bitIndex3)
    <=> v361(constB10,bitIndex3) ) ) ).

fof(is_address_32,axiom,
    address(v361_range_3_to_0_address_term_bound_10) ).

fof(address_association_31,axiom,
    v361_range_3_to_0_address_association(constB10,v361_range_3_to_0_address_term_bound_10) ).

fof(address_false_msb_31,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_9,bitIndex4) ).

fof(transient_address_definition_30,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_9,bitIndex0)
    <=> v361(constB9,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_9,bitIndex1)
    <=> v361(constB9,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_9,bitIndex2)
    <=> v361(constB9,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_9,bitIndex3)
    <=> v361(constB9,bitIndex3) ) ) ).

fof(is_address_31,axiom,
    address(v361_range_3_to_0_address_term_bound_9) ).

fof(address_association_30,axiom,
    v361_range_3_to_0_address_association(constB9,v361_range_3_to_0_address_term_bound_9) ).

fof(address_false_msb_30,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_8,bitIndex4) ).

fof(transient_address_definition_29,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_8,bitIndex0)
    <=> v361(constB8,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_8,bitIndex1)
    <=> v361(constB8,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_8,bitIndex2)
    <=> v361(constB8,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_8,bitIndex3)
    <=> v361(constB8,bitIndex3) ) ) ).

fof(is_address_30,axiom,
    address(v361_range_3_to_0_address_term_bound_8) ).

fof(address_association_29,axiom,
    v361_range_3_to_0_address_association(constB8,v361_range_3_to_0_address_term_bound_8) ).

fof(address_false_msb_29,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_7,bitIndex4) ).

fof(transient_address_definition_28,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_7,bitIndex0)
    <=> v361(constB7,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_7,bitIndex1)
    <=> v361(constB7,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_7,bitIndex2)
    <=> v361(constB7,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_7,bitIndex3)
    <=> v361(constB7,bitIndex3) ) ) ).

fof(is_address_29,axiom,
    address(v361_range_3_to_0_address_term_bound_7) ).

fof(address_association_28,axiom,
    v361_range_3_to_0_address_association(constB7,v361_range_3_to_0_address_term_bound_7) ).

fof(address_false_msb_28,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_6,bitIndex4) ).

fof(transient_address_definition_27,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_6,bitIndex0)
    <=> v361(constB6,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_6,bitIndex1)
    <=> v361(constB6,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_6,bitIndex2)
    <=> v361(constB6,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_6,bitIndex3)
    <=> v361(constB6,bitIndex3) ) ) ).

fof(is_address_28,axiom,
    address(v361_range_3_to_0_address_term_bound_6) ).

fof(address_association_27,axiom,
    v361_range_3_to_0_address_association(constB6,v361_range_3_to_0_address_term_bound_6) ).

fof(address_false_msb_27,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_5,bitIndex4) ).

fof(transient_address_definition_26,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_5,bitIndex0)
    <=> v361(constB5,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_5,bitIndex1)
    <=> v361(constB5,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_5,bitIndex2)
    <=> v361(constB5,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_5,bitIndex3)
    <=> v361(constB5,bitIndex3) ) ) ).

fof(is_address_27,axiom,
    address(v361_range_3_to_0_address_term_bound_5) ).

fof(address_association_26,axiom,
    v361_range_3_to_0_address_association(constB5,v361_range_3_to_0_address_term_bound_5) ).

fof(address_false_msb_26,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_4,bitIndex4) ).

fof(transient_address_definition_25,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_4,bitIndex0)
    <=> v361(constB4,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_4,bitIndex1)
    <=> v361(constB4,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_4,bitIndex2)
    <=> v361(constB4,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_4,bitIndex3)
    <=> v361(constB4,bitIndex3) ) ) ).

fof(is_address_26,axiom,
    address(v361_range_3_to_0_address_term_bound_4) ).

fof(address_association_25,axiom,
    v361_range_3_to_0_address_association(constB4,v361_range_3_to_0_address_term_bound_4) ).

fof(address_false_msb_25,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_3,bitIndex4) ).

fof(transient_address_definition_24,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_3,bitIndex0)
    <=> v361(constB3,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_3,bitIndex1)
    <=> v361(constB3,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_3,bitIndex2)
    <=> v361(constB3,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_3,bitIndex3)
    <=> v361(constB3,bitIndex3) ) ) ).

fof(is_address_25,axiom,
    address(v361_range_3_to_0_address_term_bound_3) ).

fof(address_association_24,axiom,
    v361_range_3_to_0_address_association(constB3,v361_range_3_to_0_address_term_bound_3) ).

fof(address_false_msb_24,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_2,bitIndex4) ).

fof(transient_address_definition_23,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_2,bitIndex0)
    <=> v361(constB2,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_2,bitIndex1)
    <=> v361(constB2,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_2,bitIndex2)
    <=> v361(constB2,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_2,bitIndex3)
    <=> v361(constB2,bitIndex3) ) ) ).

fof(is_address_24,axiom,
    address(v361_range_3_to_0_address_term_bound_2) ).

fof(address_association_23,axiom,
    v361_range_3_to_0_address_association(constB2,v361_range_3_to_0_address_term_bound_2) ).

fof(address_false_msb_23,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_1,bitIndex4) ).

fof(transient_address_definition_22,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_1,bitIndex0)
    <=> v361(constB1,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_1,bitIndex1)
    <=> v361(constB1,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_1,bitIndex2)
    <=> v361(constB1,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_1,bitIndex3)
    <=> v361(constB1,bitIndex3) ) ) ).

fof(is_address_23,axiom,
    address(v361_range_3_to_0_address_term_bound_1) ).

fof(address_association_22,axiom,
    v361_range_3_to_0_address_association(constB1,v361_range_3_to_0_address_term_bound_1) ).

fof(address_false_msb_22,axiom,
    ~ addressVal(v361_range_3_to_0_address_term_bound_0,bitIndex4) ).

fof(transient_address_definition_21,axiom,
    ( $true
    & ( addressVal(v361_range_3_to_0_address_term_bound_0,bitIndex0)
    <=> v361(constB0,bitIndex0) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_0,bitIndex1)
    <=> v361(constB0,bitIndex1) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_0,bitIndex2)
    <=> v361(constB0,bitIndex2) )
    & ( addressVal(v361_range_3_to_0_address_term_bound_0,bitIndex3)
    <=> v361(constB0,bitIndex3) ) ) ).

fof(is_address_22,axiom,
    address(v361_range_3_to_0_address_term_bound_0) ).

fof(address_association_21,axiom,
    v361_range_3_to_0_address_association(constB0,v361_range_3_to_0_address_term_bound_0) ).

fof(address_false_msb_21,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_20,bitIndex4) ).

fof(transient_address_definition_20,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_20,bitIndex0)
    <=> v333(constB20,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_20,bitIndex1)
    <=> v333(constB20,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_20,bitIndex2)
    <=> v333(constB20,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_20,bitIndex3)
    <=> v333(constB20,bitIndex3) ) ) ).

fof(is_address_21,axiom,
    address(v333_range_3_to_0_address_term_bound_20) ).

fof(address_association_20,axiom,
    v333_range_3_to_0_address_association(constB20,v333_range_3_to_0_address_term_bound_20) ).

fof(address_false_msb_20,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_19,bitIndex4) ).

fof(transient_address_definition_19,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_19,bitIndex0)
    <=> v333(constB19,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_19,bitIndex1)
    <=> v333(constB19,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_19,bitIndex2)
    <=> v333(constB19,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_19,bitIndex3)
    <=> v333(constB19,bitIndex3) ) ) ).

fof(is_address_20,axiom,
    address(v333_range_3_to_0_address_term_bound_19) ).

fof(address_association_19,axiom,
    v333_range_3_to_0_address_association(constB19,v333_range_3_to_0_address_term_bound_19) ).

fof(address_false_msb_19,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_18,bitIndex4) ).

fof(transient_address_definition_18,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_18,bitIndex0)
    <=> v333(constB18,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_18,bitIndex1)
    <=> v333(constB18,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_18,bitIndex2)
    <=> v333(constB18,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_18,bitIndex3)
    <=> v333(constB18,bitIndex3) ) ) ).

fof(is_address_19,axiom,
    address(v333_range_3_to_0_address_term_bound_18) ).

fof(address_association_18,axiom,
    v333_range_3_to_0_address_association(constB18,v333_range_3_to_0_address_term_bound_18) ).

fof(address_false_msb_18,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_17,bitIndex4) ).

fof(transient_address_definition_17,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_17,bitIndex0)
    <=> v333(constB17,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_17,bitIndex1)
    <=> v333(constB17,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_17,bitIndex2)
    <=> v333(constB17,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_17,bitIndex3)
    <=> v333(constB17,bitIndex3) ) ) ).

fof(is_address_18,axiom,
    address(v333_range_3_to_0_address_term_bound_17) ).

fof(address_association_17,axiom,
    v333_range_3_to_0_address_association(constB17,v333_range_3_to_0_address_term_bound_17) ).

fof(address_false_msb_17,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_16,bitIndex4) ).

fof(transient_address_definition_16,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_16,bitIndex0)
    <=> v333(constB16,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_16,bitIndex1)
    <=> v333(constB16,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_16,bitIndex2)
    <=> v333(constB16,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_16,bitIndex3)
    <=> v333(constB16,bitIndex3) ) ) ).

fof(is_address_17,axiom,
    address(v333_range_3_to_0_address_term_bound_16) ).

fof(address_association_16,axiom,
    v333_range_3_to_0_address_association(constB16,v333_range_3_to_0_address_term_bound_16) ).

fof(address_false_msb_16,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_15,bitIndex4) ).

fof(transient_address_definition_15,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_15,bitIndex0)
    <=> v333(constB15,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_15,bitIndex1)
    <=> v333(constB15,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_15,bitIndex2)
    <=> v333(constB15,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_15,bitIndex3)
    <=> v333(constB15,bitIndex3) ) ) ).

fof(is_address_16,axiom,
    address(v333_range_3_to_0_address_term_bound_15) ).

fof(address_association_15,axiom,
    v333_range_3_to_0_address_association(constB15,v333_range_3_to_0_address_term_bound_15) ).

fof(address_false_msb_15,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_14,bitIndex4) ).

fof(transient_address_definition_14,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_14,bitIndex0)
    <=> v333(constB14,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_14,bitIndex1)
    <=> v333(constB14,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_14,bitIndex2)
    <=> v333(constB14,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_14,bitIndex3)
    <=> v333(constB14,bitIndex3) ) ) ).

fof(is_address_15,axiom,
    address(v333_range_3_to_0_address_term_bound_14) ).

fof(address_association_14,axiom,
    v333_range_3_to_0_address_association(constB14,v333_range_3_to_0_address_term_bound_14) ).

fof(address_false_msb_14,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_13,bitIndex4) ).

fof(transient_address_definition_13,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_13,bitIndex0)
    <=> v333(constB13,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_13,bitIndex1)
    <=> v333(constB13,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_13,bitIndex2)
    <=> v333(constB13,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_13,bitIndex3)
    <=> v333(constB13,bitIndex3) ) ) ).

fof(is_address_14,axiom,
    address(v333_range_3_to_0_address_term_bound_13) ).

fof(address_association_13,axiom,
    v333_range_3_to_0_address_association(constB13,v333_range_3_to_0_address_term_bound_13) ).

fof(address_false_msb_13,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_12,bitIndex4) ).

fof(transient_address_definition_12,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_12,bitIndex0)
    <=> v333(constB12,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_12,bitIndex1)
    <=> v333(constB12,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_12,bitIndex2)
    <=> v333(constB12,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_12,bitIndex3)
    <=> v333(constB12,bitIndex3) ) ) ).

fof(is_address_13,axiom,
    address(v333_range_3_to_0_address_term_bound_12) ).

fof(address_association_12,axiom,
    v333_range_3_to_0_address_association(constB12,v333_range_3_to_0_address_term_bound_12) ).

fof(address_false_msb_12,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_11,bitIndex4) ).

fof(transient_address_definition_11,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_11,bitIndex0)
    <=> v333(constB11,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_11,bitIndex1)
    <=> v333(constB11,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_11,bitIndex2)
    <=> v333(constB11,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_11,bitIndex3)
    <=> v333(constB11,bitIndex3) ) ) ).

fof(is_address_12,axiom,
    address(v333_range_3_to_0_address_term_bound_11) ).

fof(address_association_11,axiom,
    v333_range_3_to_0_address_association(constB11,v333_range_3_to_0_address_term_bound_11) ).

fof(address_false_msb_11,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_10,bitIndex4) ).

fof(transient_address_definition_10,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_10,bitIndex0)
    <=> v333(constB10,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_10,bitIndex1)
    <=> v333(constB10,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_10,bitIndex2)
    <=> v333(constB10,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_10,bitIndex3)
    <=> v333(constB10,bitIndex3) ) ) ).

fof(is_address_11,axiom,
    address(v333_range_3_to_0_address_term_bound_10) ).

fof(address_association_10,axiom,
    v333_range_3_to_0_address_association(constB10,v333_range_3_to_0_address_term_bound_10) ).

fof(address_false_msb_10,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_9,bitIndex4) ).

fof(transient_address_definition_9,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_9,bitIndex0)
    <=> v333(constB9,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_9,bitIndex1)
    <=> v333(constB9,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_9,bitIndex2)
    <=> v333(constB9,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_9,bitIndex3)
    <=> v333(constB9,bitIndex3) ) ) ).

fof(is_address_10,axiom,
    address(v333_range_3_to_0_address_term_bound_9) ).

fof(address_association_9,axiom,
    v333_range_3_to_0_address_association(constB9,v333_range_3_to_0_address_term_bound_9) ).

fof(address_false_msb_9,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_8,bitIndex4) ).

fof(transient_address_definition_8,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_8,bitIndex0)
    <=> v333(constB8,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_8,bitIndex1)
    <=> v333(constB8,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_8,bitIndex2)
    <=> v333(constB8,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_8,bitIndex3)
    <=> v333(constB8,bitIndex3) ) ) ).

fof(is_address_9,axiom,
    address(v333_range_3_to_0_address_term_bound_8) ).

fof(address_association_8,axiom,
    v333_range_3_to_0_address_association(constB8,v333_range_3_to_0_address_term_bound_8) ).

fof(address_false_msb_8,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_7,bitIndex4) ).

fof(transient_address_definition_7,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_7,bitIndex0)
    <=> v333(constB7,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_7,bitIndex1)
    <=> v333(constB7,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_7,bitIndex2)
    <=> v333(constB7,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_7,bitIndex3)
    <=> v333(constB7,bitIndex3) ) ) ).

fof(is_address_8,axiom,
    address(v333_range_3_to_0_address_term_bound_7) ).

fof(address_association_7,axiom,
    v333_range_3_to_0_address_association(constB7,v333_range_3_to_0_address_term_bound_7) ).

fof(address_false_msb_7,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_6,bitIndex4) ).

fof(transient_address_definition_6,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_6,bitIndex0)
    <=> v333(constB6,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_6,bitIndex1)
    <=> v333(constB6,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_6,bitIndex2)
    <=> v333(constB6,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_6,bitIndex3)
    <=> v333(constB6,bitIndex3) ) ) ).

fof(is_address_7,axiom,
    address(v333_range_3_to_0_address_term_bound_6) ).

fof(address_association_6,axiom,
    v333_range_3_to_0_address_association(constB6,v333_range_3_to_0_address_term_bound_6) ).

fof(address_false_msb_6,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_5,bitIndex4) ).

fof(transient_address_definition_5,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_5,bitIndex0)
    <=> v333(constB5,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_5,bitIndex1)
    <=> v333(constB5,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_5,bitIndex2)
    <=> v333(constB5,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_5,bitIndex3)
    <=> v333(constB5,bitIndex3) ) ) ).

fof(is_address_6,axiom,
    address(v333_range_3_to_0_address_term_bound_5) ).

fof(address_association_5,axiom,
    v333_range_3_to_0_address_association(constB5,v333_range_3_to_0_address_term_bound_5) ).

fof(address_false_msb_5,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_4,bitIndex4) ).

fof(transient_address_definition_4,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_4,bitIndex0)
    <=> v333(constB4,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_4,bitIndex1)
    <=> v333(constB4,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_4,bitIndex2)
    <=> v333(constB4,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_4,bitIndex3)
    <=> v333(constB4,bitIndex3) ) ) ).

fof(is_address_5,axiom,
    address(v333_range_3_to_0_address_term_bound_4) ).

fof(address_association_4,axiom,
    v333_range_3_to_0_address_association(constB4,v333_range_3_to_0_address_term_bound_4) ).

fof(address_false_msb_4,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_3,bitIndex4) ).

fof(transient_address_definition_3,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_3,bitIndex0)
    <=> v333(constB3,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_3,bitIndex1)
    <=> v333(constB3,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_3,bitIndex2)
    <=> v333(constB3,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_3,bitIndex3)
    <=> v333(constB3,bitIndex3) ) ) ).

fof(is_address_4,axiom,
    address(v333_range_3_to_0_address_term_bound_3) ).

fof(address_association_3,axiom,
    v333_range_3_to_0_address_association(constB3,v333_range_3_to_0_address_term_bound_3) ).

fof(address_false_msb_3,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_2,bitIndex4) ).

fof(transient_address_definition_2,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_2,bitIndex0)
    <=> v333(constB2,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_2,bitIndex1)
    <=> v333(constB2,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_2,bitIndex2)
    <=> v333(constB2,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_2,bitIndex3)
    <=> v333(constB2,bitIndex3) ) ) ).

fof(is_address_3,axiom,
    address(v333_range_3_to_0_address_term_bound_2) ).

fof(address_association_2,axiom,
    v333_range_3_to_0_address_association(constB2,v333_range_3_to_0_address_term_bound_2) ).

fof(address_false_msb_2,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_1,bitIndex4) ).

fof(transient_address_definition_1,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_1,bitIndex0)
    <=> v333(constB1,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_1,bitIndex1)
    <=> v333(constB1,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_1,bitIndex2)
    <=> v333(constB1,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_1,bitIndex3)
    <=> v333(constB1,bitIndex3) ) ) ).

fof(is_address_2,axiom,
    address(v333_range_3_to_0_address_term_bound_1) ).

fof(address_association_1,axiom,
    v333_range_3_to_0_address_association(constB1,v333_range_3_to_0_address_term_bound_1) ).

fof(address_false_msb_1,axiom,
    ~ addressVal(v333_range_3_to_0_address_term_bound_0,bitIndex4) ).

fof(transient_address_definition,axiom,
    ( $true
    & ( addressVal(v333_range_3_to_0_address_term_bound_0,bitIndex0)
    <=> v333(constB0,bitIndex0) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_0,bitIndex1)
    <=> v333(constB0,bitIndex1) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_0,bitIndex2)
    <=> v333(constB0,bitIndex2) )
    & ( addressVal(v333_range_3_to_0_address_term_bound_0,bitIndex3)
    <=> v333(constB0,bitIndex3) ) ) ).

fof(is_address_1,axiom,
    address(v333_range_3_to_0_address_term_bound_0) ).

fof(address_association,axiom,
    v333_range_3_to_0_address_association(constB0,v333_range_3_to_0_address_term_bound_0) ).

fof(address_false_msb,axiom,
    ~ addressVal(b0000_address_term,bitIndex4) ).

fof(is_address,axiom,
    address(b0000_address_term) ).

fof(constant_address_definition,axiom,
    ! [B] :
      ( addressVal(b0000_address_term,B)
    <=> b0000(B) ) ).

fof(addressDiff,axiom,
    ! [B,A2,A1] :
      ( ( address(A1)
        & address(A2)
        & addressDiff(A1,A2,B) )
     => ( A1 = A2
        | ( addressVal(A1,B)
        <=> ~ addressVal(A2,B) ) ) ) ).

fof(addressDomain,axiom,
    ! [A1,A2] :
      ( addressDiff(A1,A2,bitIndex0)
      | addressDiff(A1,A2,bitIndex1)
      | addressDiff(A1,A2,bitIndex2)
      | addressDiff(A1,A2,bitIndex3)
      | addressDiff(A1,A2,bitIndex4) ) ).

fof(addAssertion,conjecture,
    ! [VarCurr] :
      ( reachableState(VarCurr)
     => v4(VarCurr) ) ).

fof(writeUnaryOperator_864,axiom,
    ! [VarCurr] :
      ( ~ v4(VarCurr)
    <=> v9871(VarCurr) ) ).

fof(writeUnaryOperator_863,axiom,
    ! [VarCurr] :
      ( ~ v9871(VarCurr)
    <=> v9872(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1924,axiom,
    ! [VarCurr] :
      ( v9872(VarCurr)
    <=> ( v9874(VarCurr)
        & v9891(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_380,axiom,
    ! [VarCurr] :
      ( v9891(VarCurr)
    <=> ( v9892(VarCurr)
        | v6(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_379,axiom,
    ! [VarCurr] :
      ( v9892(VarCurr)
    <=> ( v9893(VarCurr)
        | v6(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_378,axiom,
    ! [VarCurr] :
      ( v9893(VarCurr)
    <=> ( v6(VarCurr,bitIndex0)
        | v6(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1923,axiom,
    ! [VarCurr] :
      ( v9874(VarCurr)
    <=> ( v9875(VarCurr)
        | v9882(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1922,axiom,
    ! [VarCurr] :
      ( v9882(VarCurr)
    <=> ( v9883(VarCurr)
        | v9884(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1921,axiom,
    ! [VarCurr] :
      ( v9884(VarCurr)
    <=> ( v9876(VarCurr)
        & v9885(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1920,axiom,
    ! [VarCurr] :
      ( v9885(VarCurr)
    <=> ( v9886(VarCurr)
        | v9887(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1919,axiom,
    ! [VarCurr] :
      ( v9887(VarCurr)
    <=> ( v9878(VarCurr)
        & v9888(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1918,axiom,
    ! [VarCurr] :
      ( v9888(VarCurr)
    <=> ( v9889(VarCurr)
        | v9890(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1917,axiom,
    ! [VarCurr] :
      ( v9890(VarCurr)
    <=> ( v6(VarCurr,bitIndex0)
        & v9881(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_377,axiom,
    ! [VarCurr] :
      ( v9889(VarCurr)
    <=> ( v9880(VarCurr)
        & v6(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorShiftedRanges_376,axiom,
    ! [VarCurr] :
      ( v9886(VarCurr)
    <=> ( v6(VarCurr,bitIndex2)
        & v9879(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_375,axiom,
    ! [VarCurr] :
      ( v9883(VarCurr)
    <=> ( v6(VarCurr,bitIndex3)
        & v9877(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1916,axiom,
    ! [VarCurr] :
      ( v9875(VarCurr)
    <=> ( v9876(VarCurr)
        & v9877(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1915,axiom,
    ! [VarCurr] :
      ( v9877(VarCurr)
    <=> ( v9878(VarCurr)
        & v9879(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1914,axiom,
    ! [VarCurr] :
      ( v9879(VarCurr)
    <=> ( v9880(VarCurr)
        & v9881(VarCurr) ) ) ).

fof(writeUnaryOperator_862,axiom,
    ! [VarCurr] :
      ( ~ v9881(VarCurr)
    <=> v6(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_861,axiom,
    ! [VarCurr] :
      ( ~ v9880(VarCurr)
    <=> v6(VarCurr,bitIndex0) ) ).

fof(writeUnaryOperator_860,axiom,
    ! [VarCurr] :
      ( ~ v9878(VarCurr)
    <=> v6(VarCurr,bitIndex2) ) ).

fof(writeUnaryOperator_859,axiom,
    ! [VarCurr] :
      ( ~ v9876(VarCurr)
    <=> v6(VarCurr,bitIndex3) ) ).

fof(addCaseBooleanConditionEqualRanges1_165,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9859(VarNext)
       => ! [B] :
            ( range_3_1(B)
           => ( v6(VarNext,B)
            <=> v6(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionShiftedRanges0_9,axiom,
    ! [VarNext] :
      ( v9859(VarNext)
     => ( ( v6(VarNext,bitIndex3)
        <=> v9867(VarNext,bitIndex2) )
        & ( v6(VarNext,bitIndex2)
        <=> v9867(VarNext,bitIndex1) )
        & ( v6(VarNext,bitIndex1)
        <=> v9867(VarNext,bitIndex0) ) ) ) ).

fof(addAssignment_2295,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v9867(VarNext,B)
          <=> v9865(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_115,axiom,
    ! [VarCurr] :
      ( ~ v9141(VarCurr)
     => ( ( v9865(VarCurr,bitIndex2)
        <=> v19(VarCurr,bitIndex3) )
        & ( v9865(VarCurr,bitIndex1)
        <=> v19(VarCurr,bitIndex2) )
        & ( v9865(VarCurr,bitIndex0)
        <=> v19(VarCurr,bitIndex1) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_265,axiom,
    ! [VarCurr] :
      ( v9141(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9865(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1913,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9859(VarNext)
      <=> v9860(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1912,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9860(VarNext)
      <=> ( v9862(VarNext)
          & v9127(VarNext) ) ) ) ).

fof(writeUnaryOperator_858,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9862(VarNext)
      <=> v9134(VarNext) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_164,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9846(VarNext)
       => ( v6(VarNext,bitIndex0)
        <=> v6(VarCurr,bitIndex0) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_185,axiom,
    ! [VarNext] :
      ( v9846(VarNext)
     => ( v6(VarNext,bitIndex0)
      <=> v9854(VarNext) ) ) ).

fof(addAssignment_2294,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9854(VarNext)
      <=> v9852(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_260,axiom,
    ! [VarCurr] :
      ( ~ v9141(VarCurr)
     => ( v9852(VarCurr)
      <=> v19(VarCurr,bitIndex0) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_264,axiom,
    ! [VarCurr] :
      ( v9141(VarCurr)
     => ( v9852(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1911,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9846(VarNext)
      <=> v9847(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1910,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9847(VarNext)
      <=> ( v9849(VarNext)
          & v9127(VarNext) ) ) ) ).

fof(writeUnaryOperator_857,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9849(VarNext)
      <=> v9134(VarNext) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_114,axiom,
    ! [VarCurr] :
      ( ~ v9840(VarCurr)
     => ( v19(VarCurr,bitIndex3)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_110,axiom,
    ! [VarCurr] :
      ( v9840(VarCurr)
     => ( v19(VarCurr,bitIndex3)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1909,axiom,
    ! [VarCurr] :
      ( v9840(VarCurr)
    <=> ( v9841(VarCurr)
        | v9842(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1908,axiom,
    ! [VarCurr] :
      ( v9842(VarCurr)
    <=> ( v9843(VarCurr)
        & v9112(VarCurr) ) ) ).

fof(writeUnaryOperator_856,axiom,
    ! [VarCurr] :
      ( ~ v9843(VarCurr)
    <=> v3018(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1907,axiom,
    ! [VarCurr] :
      ( v9841(VarCurr)
    <=> ( v3018(VarCurr)
        & v9111(VarCurr) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_113,axiom,
    ! [VarCurr] :
      ( ~ v9835(VarCurr)
     => ( v19(VarCurr,bitIndex2)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_109,axiom,
    ! [VarCurr] :
      ( v9835(VarCurr)
     => ( v19(VarCurr,bitIndex2)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1906,axiom,
    ! [VarCurr] :
      ( v9835(VarCurr)
    <=> ( v9836(VarCurr)
        | v9837(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1905,axiom,
    ! [VarCurr] :
      ( v9837(VarCurr)
    <=> ( v9838(VarCurr)
        & v9111(VarCurr) ) ) ).

fof(writeUnaryOperator_855,axiom,
    ! [VarCurr] :
      ( ~ v9838(VarCurr)
    <=> v3018(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1904,axiom,
    ! [VarCurr] :
      ( v9836(VarCurr)
    <=> ( v9119(VarCurr)
        & v9110(VarCurr) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_112,axiom,
    ! [VarCurr] :
      ( ~ v9830(VarCurr)
     => ( v19(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_108,axiom,
    ! [VarCurr] :
      ( v9830(VarCurr)
     => ( v19(VarCurr,bitIndex1)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1903,axiom,
    ! [VarCurr] :
      ( v9830(VarCurr)
    <=> ( v9831(VarCurr)
        | v9832(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1902,axiom,
    ! [VarCurr] :
      ( v9832(VarCurr)
    <=> ( v9833(VarCurr)
        & v9113(VarCurr) ) ) ).

fof(writeUnaryOperator_854,axiom,
    ! [VarCurr] :
      ( ~ v9833(VarCurr)
    <=> v3018(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1901,axiom,
    ! [VarCurr] :
      ( v9831(VarCurr)
    <=> ( v9122(VarCurr)
        & v9110(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_259,axiom,
    ! [VarCurr] :
      ( ~ v9824(VarCurr)
     => ( v19(VarCurr,bitIndex0)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_263,axiom,
    ! [VarCurr] :
      ( v9824(VarCurr)
     => ( v19(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1900,axiom,
    ! [VarCurr] :
      ( v9824(VarCurr)
    <=> ( v9825(VarCurr)
        | v9828(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1899,axiom,
    ! [VarCurr] :
      ( v9828(VarCurr)
    <=> ( v3018(VarCurr)
        & v9113(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1898,axiom,
    ! [VarCurr] :
      ( v9825(VarCurr)
    <=> ( v9826(VarCurr)
        | v9827(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1897,axiom,
    ! [VarCurr] :
      ( v9827(VarCurr)
    <=> ( v3018(VarCurr)
        & v9112(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1896,axiom,
    ! [VarCurr] :
      ( v9826(VarCurr)
    <=> ( v9116(VarCurr)
        & v9110(VarCurr) ) ) ).

fof(addAssignment_2293,axiom,
    ! [VarCurr] :
      ( v21(VarCurr)
    <=> v23(VarCurr) ) ).

fof(addAssignment_2292,axiom,
    ! [VarCurr] :
      ( v23(VarCurr)
    <=> v25(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_258,axiom,
    ! [VarCurr] :
      ( ~ v9820(VarCurr)
     => ( v25(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_262,axiom,
    ! [VarCurr] :
      ( v9820(VarCurr)
     => ( v25(VarCurr)
      <=> v9822(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_257,axiom,
    ! [VarCurr] :
      ( ~ v3006(VarCurr)
     => ( v9822(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_261,axiom,
    ! [VarCurr] :
      ( v3006(VarCurr)
     => ( v9822(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1895,axiom,
    ! [VarCurr] :
      ( v9820(VarCurr)
    <=> ( v9821(VarCurr)
        & v9306(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1894,axiom,
    ! [VarCurr] :
      ( v9821(VarCurr)
    <=> ( v9304(VarCurr)
        & v9305(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_256,axiom,
    ! [VarCurr] :
      ( ~ v29(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v27(VarCurr,B)
          <=> v9791(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_260,axiom,
    ! [VarCurr] :
      ( v29(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v27(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_49,axiom,
    ! [VarCurr] :
      ( ( ~ v9792(VarCurr)
        & ~ v9812(VarCurr)
        & ~ v9813(VarCurr) )
     => ! [B] :
          ( range_1_0(B)
         => ( v9791(VarCurr,B)
          <=> $true ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_104,axiom,
    ! [VarCurr] :
      ( v9813(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v9791(VarCurr,B)
          <=> b10(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_267,axiom,
    ! [VarCurr] :
      ( v9812(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v9791(VarCurr,B)
          <=> b01(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_255,axiom,
    ! [VarCurr] :
      ( v9792(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v9791(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1893,axiom,
    ! [VarCurr] :
      ( v9813(VarCurr)
    <=> ( v9815(VarCurr)
        | v9818(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_738,axiom,
    ! [VarCurr] :
      ( v9818(VarCurr)
    <=> ( ( v9715(VarCurr,bitIndex6)
        <=> $true )
        & ( v9715(VarCurr,bitIndex5)
        <=> $false )
        & ( v9715(VarCurr,bitIndex4)
        <=> $false )
        & ( v9715(VarCurr,bitIndex3)
        <=> $true )
        & ( v9715(VarCurr,bitIndex2)
        <=> $false )
        & ( v9715(VarCurr,bitIndex1)
        <=> $true )
        & ( v9715(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1892,axiom,
    ! [VarCurr] :
      ( v9815(VarCurr)
    <=> ( v9816(VarCurr)
        | v9817(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_737,axiom,
    ! [VarCurr] :
      ( v9817(VarCurr)
    <=> ( ( v9715(VarCurr,bitIndex6)
        <=> $false )
        & ( v9715(VarCurr,bitIndex5)
        <=> $false )
        & ( v9715(VarCurr,bitIndex4)
        <=> $false )
        & ( v9715(VarCurr,bitIndex3)
        <=> $true )
        & ( v9715(VarCurr,bitIndex2)
        <=> $false )
        & ( v9715(VarCurr,bitIndex1)
        <=> $true )
        & ( v9715(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_736,axiom,
    ! [VarCurr] :
      ( v9816(VarCurr)
    <=> ( ( v9715(VarCurr,bitIndex6)
        <=> $false )
        & ( v9715(VarCurr,bitIndex5)
        <=> $false )
        & ( v9715(VarCurr,bitIndex4)
        <=> $false )
        & ( v9715(VarCurr,bitIndex3)
        <=> $true )
        & ( v9715(VarCurr,bitIndex2)
        <=> $false )
        & ( v9715(VarCurr,bitIndex1)
        <=> $true )
        & ( v9715(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_735,axiom,
    ! [VarCurr] :
      ( v9812(VarCurr)
    <=> ( ( v9715(VarCurr,bitIndex6)
        <=> $true )
        & ( v9715(VarCurr,bitIndex5)
        <=> $true )
        & ( v9715(VarCurr,bitIndex4)
        <=> $true )
        & ( v9715(VarCurr,bitIndex3)
        <=> $true )
        & ( v9715(VarCurr,bitIndex2)
        <=> $false )
        & ( v9715(VarCurr,bitIndex1)
        <=> $true )
        & ( v9715(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1891,axiom,
    ! [VarCurr] :
      ( v9792(VarCurr)
    <=> ( v9794(VarCurr)
        | v9811(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_734,axiom,
    ! [VarCurr] :
      ( v9811(VarCurr)
    <=> ( ( v9715(VarCurr,bitIndex6)
        <=> $true )
        & ( v9715(VarCurr,bitIndex5)
        <=> $false )
        & ( v9715(VarCurr,bitIndex4)
        <=> $false )
        & ( v9715(VarCurr,bitIndex3)
        <=> $false )
        & ( v9715(VarCurr,bitIndex2)
        <=> $true )
        & ( v9715(VarCurr,bitIndex1)
        <=> $false )
        & ( v9715(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1890,axiom,
    ! [VarCurr] :
      ( v9794(VarCurr)
    <=> ( v9795(VarCurr)
        | v9810(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_733,axiom,
    ! [VarCurr] :
      ( v9810(VarCurr)
    <=> ( ( v9715(VarCurr,bitIndex6)
        <=> $true )
        & ( v9715(VarCurr,bitIndex5)
        <=> $false )
        & ( v9715(VarCurr,bitIndex4)
        <=> $false )
        & ( v9715(VarCurr,bitIndex3)
        <=> $false )
        & ( v9715(VarCurr,bitIndex2)
        <=> $true )
        & ( v9715(VarCurr,bitIndex1)
        <=> $false )
        & ( v9715(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1889,axiom,
    ! [VarCurr] :
      ( v9795(VarCurr)
    <=> ( v9796(VarCurr)
        | v9809(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_732,axiom,
    ! [VarCurr] :
      ( v9809(VarCurr)
    <=> ( ( v9715(VarCurr,bitIndex6)
        <=> $true )
        & ( v9715(VarCurr,bitIndex5)
        <=> $true )
        & ( v9715(VarCurr,bitIndex4)
        <=> $false )
        & ( v9715(VarCurr,bitIndex3)
        <=> $false )
        & ( v9715(VarCurr,bitIndex2)
        <=> $false )
        & ( v9715(VarCurr,bitIndex1)
        <=> $false )
        & ( v9715(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1888,axiom,
    ! [VarCurr] :
      ( v9796(VarCurr)
    <=> ( v9797(VarCurr)
        | v9808(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_731,axiom,
    ! [VarCurr] :
      ( v9808(VarCurr)
    <=> ( ( v9715(VarCurr,bitIndex6)
        <=> $true )
        & ( v9715(VarCurr,bitIndex5)
        <=> $false )
        & ( v9715(VarCurr,bitIndex4)
        <=> $false )
        & ( v9715(VarCurr,bitIndex3)
        <=> $false )
        & ( v9715(VarCurr,bitIndex2)
        <=> $false )
        & ( v9715(VarCurr,bitIndex1)
        <=> $false )
        & ( v9715(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1887,axiom,
    ! [VarCurr] :
      ( v9797(VarCurr)
    <=> ( v9798(VarCurr)
        | v9807(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_730,axiom,
    ! [VarCurr] :
      ( v9807(VarCurr)
    <=> ( ( v9715(VarCurr,bitIndex6)
        <=> $true )
        & ( v9715(VarCurr,bitIndex5)
        <=> $false )
        & ( v9715(VarCurr,bitIndex4)
        <=> $false )
        & ( v9715(VarCurr,bitIndex3)
        <=> $false )
        & ( v9715(VarCurr,bitIndex2)
        <=> $false )
        & ( v9715(VarCurr,bitIndex1)
        <=> $true )
        & ( v9715(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1886,axiom,
    ! [VarCurr] :
      ( v9798(VarCurr)
    <=> ( v9799(VarCurr)
        | v9806(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_729,axiom,
    ! [VarCurr] :
      ( v9806(VarCurr)
    <=> ( ( v9715(VarCurr,bitIndex6)
        <=> $false )
        & ( v9715(VarCurr,bitIndex5)
        <=> $false )
        & ( v9715(VarCurr,bitIndex4)
        <=> $false )
        & ( v9715(VarCurr,bitIndex3)
        <=> $false )
        & ( v9715(VarCurr,bitIndex2)
        <=> $true )
        & ( v9715(VarCurr,bitIndex1)
        <=> $false )
        & ( v9715(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1885,axiom,
    ! [VarCurr] :
      ( v9799(VarCurr)
    <=> ( v9800(VarCurr)
        | v9805(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_728,axiom,
    ! [VarCurr] :
      ( v9805(VarCurr)
    <=> ( ( v9715(VarCurr,bitIndex6)
        <=> $false )
        & ( v9715(VarCurr,bitIndex5)
        <=> $false )
        & ( v9715(VarCurr,bitIndex4)
        <=> $false )
        & ( v9715(VarCurr,bitIndex3)
        <=> $false )
        & ( v9715(VarCurr,bitIndex2)
        <=> $true )
        & ( v9715(VarCurr,bitIndex1)
        <=> $false )
        & ( v9715(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1884,axiom,
    ! [VarCurr] :
      ( v9800(VarCurr)
    <=> ( v9801(VarCurr)
        | v9804(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_727,axiom,
    ! [VarCurr] :
      ( v9804(VarCurr)
    <=> ( ( v9715(VarCurr,bitIndex6)
        <=> $false )
        & ( v9715(VarCurr,bitIndex5)
        <=> $false )
        & ( v9715(VarCurr,bitIndex4)
        <=> $false )
        & ( v9715(VarCurr,bitIndex3)
        <=> $false )
        & ( v9715(VarCurr,bitIndex2)
        <=> $false )
        & ( v9715(VarCurr,bitIndex1)
        <=> $true )
        & ( v9715(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1883,axiom,
    ! [VarCurr] :
      ( v9801(VarCurr)
    <=> ( v9802(VarCurr)
        | v9803(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_726,axiom,
    ! [VarCurr] :
      ( v9803(VarCurr)
    <=> ( ( v9715(VarCurr,bitIndex6)
        <=> $false )
        & ( v9715(VarCurr,bitIndex5)
        <=> $true )
        & ( v9715(VarCurr,bitIndex4)
        <=> $false )
        & ( v9715(VarCurr,bitIndex3)
        <=> $false )
        & ( v9715(VarCurr,bitIndex2)
        <=> $false )
        & ( v9715(VarCurr,bitIndex1)
        <=> $false )
        & ( v9715(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_725,axiom,
    ! [VarCurr] :
      ( v9802(VarCurr)
    <=> ( ( v9715(VarCurr,bitIndex6)
        <=> $false )
        & ( v9715(VarCurr,bitIndex5)
        <=> $false )
        & ( v9715(VarCurr,bitIndex4)
        <=> $false )
        & ( v9715(VarCurr,bitIndex3)
        <=> $false )
        & ( v9715(VarCurr,bitIndex2)
        <=> $false )
        & ( v9715(VarCurr,bitIndex1)
        <=> $false )
        & ( v9715(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2291,axiom,
    ! [VarCurr] :
      ( ( v9715(VarCurr,bitIndex6)
      <=> v3062(VarCurr,bitIndex69) )
      & ( v9715(VarCurr,bitIndex5)
      <=> v3062(VarCurr,bitIndex68) )
      & ( v9715(VarCurr,bitIndex4)
      <=> v3062(VarCurr,bitIndex67) )
      & ( v9715(VarCurr,bitIndex3)
      <=> v3062(VarCurr,bitIndex66) )
      & ( v9715(VarCurr,bitIndex2)
      <=> v3062(VarCurr,bitIndex65) )
      & ( v9715(VarCurr,bitIndex1)
      <=> v3062(VarCurr,bitIndex64) )
      & ( v9715(VarCurr,bitIndex0)
      <=> v3062(VarCurr,bitIndex63) ) ) ).

fof(addAssignment_2290,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v3062(VarCurr,B)
      <=> v3064(VarCurr,B) ) ) ).

fof(addAssignment_2289,axiom,
    ! [VarCurr] :
      ( ( v3064(VarCurr,bitIndex69)
      <=> v3066(VarCurr,bitIndex559) )
      & ( v3064(VarCurr,bitIndex68)
      <=> v3066(VarCurr,bitIndex558) )
      & ( v3064(VarCurr,bitIndex67)
      <=> v3066(VarCurr,bitIndex557) )
      & ( v3064(VarCurr,bitIndex66)
      <=> v3066(VarCurr,bitIndex556) )
      & ( v3064(VarCurr,bitIndex65)
      <=> v3066(VarCurr,bitIndex555) )
      & ( v3064(VarCurr,bitIndex64)
      <=> v3066(VarCurr,bitIndex554) )
      & ( v3064(VarCurr,bitIndex63)
      <=> v3066(VarCurr,bitIndex553) ) ) ).

fof(addAssignment_2288,axiom,
    ! [VarNext] :
      ( ( v3066(VarNext,bitIndex559)
      <=> v9783(VarNext,bitIndex69) )
      & ( v3066(VarNext,bitIndex558)
      <=> v9783(VarNext,bitIndex68) )
      & ( v3066(VarNext,bitIndex557)
      <=> v9783(VarNext,bitIndex67) )
      & ( v3066(VarNext,bitIndex556)
      <=> v9783(VarNext,bitIndex66) )
      & ( v3066(VarNext,bitIndex555)
      <=> v9783(VarNext,bitIndex65) )
      & ( v3066(VarNext,bitIndex554)
      <=> v9783(VarNext,bitIndex64) )
      & ( v3066(VarNext,bitIndex553)
      <=> v9783(VarNext,bitIndex63) ) ) ).

fof(addCaseBooleanConditionShiftedRanges1_29,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9785(VarNext)
       => ( ( v9783(VarNext,bitIndex69)
          <=> v3066(VarCurr,bitIndex559) )
          & ( v9783(VarNext,bitIndex68)
          <=> v3066(VarCurr,bitIndex558) )
          & ( v9783(VarNext,bitIndex67)
          <=> v3066(VarCurr,bitIndex557) )
          & ( v9783(VarNext,bitIndex66)
          <=> v3066(VarCurr,bitIndex556) )
          & ( v9783(VarNext,bitIndex65)
          <=> v3066(VarCurr,bitIndex555) )
          & ( v9783(VarNext,bitIndex64)
          <=> v3066(VarCurr,bitIndex554) )
          & ( v9783(VarNext,bitIndex63)
          <=> v3066(VarCurr,bitIndex553) )
          & ( v9783(VarNext,bitIndex62)
          <=> v3066(VarCurr,bitIndex552) )
          & ( v9783(VarNext,bitIndex61)
          <=> v3066(VarCurr,bitIndex551) )
          & ( v9783(VarNext,bitIndex60)
          <=> v3066(VarCurr,bitIndex550) )
          & ( v9783(VarNext,bitIndex59)
          <=> v3066(VarCurr,bitIndex549) )
          & ( v9783(VarNext,bitIndex58)
          <=> v3066(VarCurr,bitIndex548) )
          & ( v9783(VarNext,bitIndex57)
          <=> v3066(VarCurr,bitIndex547) )
          & ( v9783(VarNext,bitIndex56)
          <=> v3066(VarCurr,bitIndex546) )
          & ( v9783(VarNext,bitIndex55)
          <=> v3066(VarCurr,bitIndex545) )
          & ( v9783(VarNext,bitIndex54)
          <=> v3066(VarCurr,bitIndex544) )
          & ( v9783(VarNext,bitIndex53)
          <=> v3066(VarCurr,bitIndex543) )
          & ( v9783(VarNext,bitIndex52)
          <=> v3066(VarCurr,bitIndex542) )
          & ( v9783(VarNext,bitIndex51)
          <=> v3066(VarCurr,bitIndex541) )
          & ( v9783(VarNext,bitIndex50)
          <=> v3066(VarCurr,bitIndex540) )
          & ( v9783(VarNext,bitIndex49)
          <=> v3066(VarCurr,bitIndex539) )
          & ( v9783(VarNext,bitIndex48)
          <=> v3066(VarCurr,bitIndex538) )
          & ( v9783(VarNext,bitIndex47)
          <=> v3066(VarCurr,bitIndex537) )
          & ( v9783(VarNext,bitIndex46)
          <=> v3066(VarCurr,bitIndex536) )
          & ( v9783(VarNext,bitIndex45)
          <=> v3066(VarCurr,bitIndex535) )
          & ( v9783(VarNext,bitIndex44)
          <=> v3066(VarCurr,bitIndex534) )
          & ( v9783(VarNext,bitIndex43)
          <=> v3066(VarCurr,bitIndex533) )
          & ( v9783(VarNext,bitIndex42)
          <=> v3066(VarCurr,bitIndex532) )
          & ( v9783(VarNext,bitIndex41)
          <=> v3066(VarCurr,bitIndex531) )
          & ( v9783(VarNext,bitIndex40)
          <=> v3066(VarCurr,bitIndex530) )
          & ( v9783(VarNext,bitIndex39)
          <=> v3066(VarCurr,bitIndex529) )
          & ( v9783(VarNext,bitIndex38)
          <=> v3066(VarCurr,bitIndex528) )
          & ( v9783(VarNext,bitIndex37)
          <=> v3066(VarCurr,bitIndex527) )
          & ( v9783(VarNext,bitIndex36)
          <=> v3066(VarCurr,bitIndex526) )
          & ( v9783(VarNext,bitIndex35)
          <=> v3066(VarCurr,bitIndex525) )
          & ( v9783(VarNext,bitIndex34)
          <=> v3066(VarCurr,bitIndex524) )
          & ( v9783(VarNext,bitIndex33)
          <=> v3066(VarCurr,bitIndex523) )
          & ( v9783(VarNext,bitIndex32)
          <=> v3066(VarCurr,bitIndex522) )
          & ( v9783(VarNext,bitIndex31)
          <=> v3066(VarCurr,bitIndex521) )
          & ( v9783(VarNext,bitIndex30)
          <=> v3066(VarCurr,bitIndex520) )
          & ( v9783(VarNext,bitIndex29)
          <=> v3066(VarCurr,bitIndex519) )
          & ( v9783(VarNext,bitIndex28)
          <=> v3066(VarCurr,bitIndex518) )
          & ( v9783(VarNext,bitIndex27)
          <=> v3066(VarCurr,bitIndex517) )
          & ( v9783(VarNext,bitIndex26)
          <=> v3066(VarCurr,bitIndex516) )
          & ( v9783(VarNext,bitIndex25)
          <=> v3066(VarCurr,bitIndex515) )
          & ( v9783(VarNext,bitIndex24)
          <=> v3066(VarCurr,bitIndex514) )
          & ( v9783(VarNext,bitIndex23)
          <=> v3066(VarCurr,bitIndex513) )
          & ( v9783(VarNext,bitIndex22)
          <=> v3066(VarCurr,bitIndex512) )
          & ( v9783(VarNext,bitIndex21)
          <=> v3066(VarCurr,bitIndex511) )
          & ( v9783(VarNext,bitIndex20)
          <=> v3066(VarCurr,bitIndex510) )
          & ( v9783(VarNext,bitIndex19)
          <=> v3066(VarCurr,bitIndex509) )
          & ( v9783(VarNext,bitIndex18)
          <=> v3066(VarCurr,bitIndex508) )
          & ( v9783(VarNext,bitIndex17)
          <=> v3066(VarCurr,bitIndex507) )
          & ( v9783(VarNext,bitIndex16)
          <=> v3066(VarCurr,bitIndex506) )
          & ( v9783(VarNext,bitIndex15)
          <=> v3066(VarCurr,bitIndex505) )
          & ( v9783(VarNext,bitIndex14)
          <=> v3066(VarCurr,bitIndex504) )
          & ( v9783(VarNext,bitIndex13)
          <=> v3066(VarCurr,bitIndex503) )
          & ( v9783(VarNext,bitIndex12)
          <=> v3066(VarCurr,bitIndex502) )
          & ( v9783(VarNext,bitIndex11)
          <=> v3066(VarCurr,bitIndex501) )
          & ( v9783(VarNext,bitIndex10)
          <=> v3066(VarCurr,bitIndex500) )
          & ( v9783(VarNext,bitIndex9)
          <=> v3066(VarCurr,bitIndex499) )
          & ( v9783(VarNext,bitIndex8)
          <=> v3066(VarCurr,bitIndex498) )
          & ( v9783(VarNext,bitIndex7)
          <=> v3066(VarCurr,bitIndex497) )
          & ( v9783(VarNext,bitIndex6)
          <=> v3066(VarCurr,bitIndex496) )
          & ( v9783(VarNext,bitIndex5)
          <=> v3066(VarCurr,bitIndex495) )
          & ( v9783(VarNext,bitIndex4)
          <=> v3066(VarCurr,bitIndex494) )
          & ( v9783(VarNext,bitIndex3)
          <=> v3066(VarCurr,bitIndex493) )
          & ( v9783(VarNext,bitIndex2)
          <=> v3066(VarCurr,bitIndex492) )
          & ( v9783(VarNext,bitIndex1)
          <=> v3066(VarCurr,bitIndex491) )
          & ( v9783(VarNext,bitIndex0)
          <=> v3066(VarCurr,bitIndex490) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_184,axiom,
    ! [VarNext] :
      ( v9785(VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v9783(VarNext,B)
          <=> v9101(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1882,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9785(VarNext)
      <=> ( v9786(VarNext)
          & v9083(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1881,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9786(VarNext)
      <=> ( v9788(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_853,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9788(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2287,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v9067(VarCurr,B)
      <=> v9072(VarCurr,B) ) ) ).

fof(addAssignment_2286,axiom,
    ! [VarCurr] :
      ( ( v9071(VarCurr,bitIndex69)
      <=> v3066(VarCurr,bitIndex489) )
      & ( v9071(VarCurr,bitIndex68)
      <=> v3066(VarCurr,bitIndex488) )
      & ( v9071(VarCurr,bitIndex67)
      <=> v3066(VarCurr,bitIndex487) )
      & ( v9071(VarCurr,bitIndex66)
      <=> v3066(VarCurr,bitIndex486) )
      & ( v9071(VarCurr,bitIndex65)
      <=> v3066(VarCurr,bitIndex485) )
      & ( v9071(VarCurr,bitIndex64)
      <=> v3066(VarCurr,bitIndex484) )
      & ( v9071(VarCurr,bitIndex63)
      <=> v3066(VarCurr,bitIndex483) ) ) ).

fof(addAssignment_2285,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v9060(VarCurr,B)
      <=> v9065(VarCurr,B) ) ) ).

fof(addAssignment_2284,axiom,
    ! [VarCurr] :
      ( ( v9064(VarCurr,bitIndex69)
      <=> v3066(VarCurr,bitIndex559) )
      & ( v9064(VarCurr,bitIndex68)
      <=> v3066(VarCurr,bitIndex558) )
      & ( v9064(VarCurr,bitIndex67)
      <=> v3066(VarCurr,bitIndex557) )
      & ( v9064(VarCurr,bitIndex66)
      <=> v3066(VarCurr,bitIndex556) )
      & ( v9064(VarCurr,bitIndex65)
      <=> v3066(VarCurr,bitIndex555) )
      & ( v9064(VarCurr,bitIndex64)
      <=> v3066(VarCurr,bitIndex554) )
      & ( v9064(VarCurr,bitIndex63)
      <=> v3066(VarCurr,bitIndex553) ) ) ).

fof(addAssignment_2283,axiom,
    ! [VarNext] :
      ( ( v3066(VarNext,bitIndex489)
      <=> v9775(VarNext,bitIndex69) )
      & ( v3066(VarNext,bitIndex488)
      <=> v9775(VarNext,bitIndex68) )
      & ( v3066(VarNext,bitIndex487)
      <=> v9775(VarNext,bitIndex67) )
      & ( v3066(VarNext,bitIndex486)
      <=> v9775(VarNext,bitIndex66) )
      & ( v3066(VarNext,bitIndex485)
      <=> v9775(VarNext,bitIndex65) )
      & ( v3066(VarNext,bitIndex484)
      <=> v9775(VarNext,bitIndex64) )
      & ( v3066(VarNext,bitIndex483)
      <=> v9775(VarNext,bitIndex63) ) ) ).

fof(addCaseBooleanConditionShiftedRanges1_28,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9777(VarNext)
       => ( ( v9775(VarNext,bitIndex69)
          <=> v3066(VarCurr,bitIndex489) )
          & ( v9775(VarNext,bitIndex68)
          <=> v3066(VarCurr,bitIndex488) )
          & ( v9775(VarNext,bitIndex67)
          <=> v3066(VarCurr,bitIndex487) )
          & ( v9775(VarNext,bitIndex66)
          <=> v3066(VarCurr,bitIndex486) )
          & ( v9775(VarNext,bitIndex65)
          <=> v3066(VarCurr,bitIndex485) )
          & ( v9775(VarNext,bitIndex64)
          <=> v3066(VarCurr,bitIndex484) )
          & ( v9775(VarNext,bitIndex63)
          <=> v3066(VarCurr,bitIndex483) )
          & ( v9775(VarNext,bitIndex62)
          <=> v3066(VarCurr,bitIndex482) )
          & ( v9775(VarNext,bitIndex61)
          <=> v3066(VarCurr,bitIndex481) )
          & ( v9775(VarNext,bitIndex60)
          <=> v3066(VarCurr,bitIndex480) )
          & ( v9775(VarNext,bitIndex59)
          <=> v3066(VarCurr,bitIndex479) )
          & ( v9775(VarNext,bitIndex58)
          <=> v3066(VarCurr,bitIndex478) )
          & ( v9775(VarNext,bitIndex57)
          <=> v3066(VarCurr,bitIndex477) )
          & ( v9775(VarNext,bitIndex56)
          <=> v3066(VarCurr,bitIndex476) )
          & ( v9775(VarNext,bitIndex55)
          <=> v3066(VarCurr,bitIndex475) )
          & ( v9775(VarNext,bitIndex54)
          <=> v3066(VarCurr,bitIndex474) )
          & ( v9775(VarNext,bitIndex53)
          <=> v3066(VarCurr,bitIndex473) )
          & ( v9775(VarNext,bitIndex52)
          <=> v3066(VarCurr,bitIndex472) )
          & ( v9775(VarNext,bitIndex51)
          <=> v3066(VarCurr,bitIndex471) )
          & ( v9775(VarNext,bitIndex50)
          <=> v3066(VarCurr,bitIndex470) )
          & ( v9775(VarNext,bitIndex49)
          <=> v3066(VarCurr,bitIndex469) )
          & ( v9775(VarNext,bitIndex48)
          <=> v3066(VarCurr,bitIndex468) )
          & ( v9775(VarNext,bitIndex47)
          <=> v3066(VarCurr,bitIndex467) )
          & ( v9775(VarNext,bitIndex46)
          <=> v3066(VarCurr,bitIndex466) )
          & ( v9775(VarNext,bitIndex45)
          <=> v3066(VarCurr,bitIndex465) )
          & ( v9775(VarNext,bitIndex44)
          <=> v3066(VarCurr,bitIndex464) )
          & ( v9775(VarNext,bitIndex43)
          <=> v3066(VarCurr,bitIndex463) )
          & ( v9775(VarNext,bitIndex42)
          <=> v3066(VarCurr,bitIndex462) )
          & ( v9775(VarNext,bitIndex41)
          <=> v3066(VarCurr,bitIndex461) )
          & ( v9775(VarNext,bitIndex40)
          <=> v3066(VarCurr,bitIndex460) )
          & ( v9775(VarNext,bitIndex39)
          <=> v3066(VarCurr,bitIndex459) )
          & ( v9775(VarNext,bitIndex38)
          <=> v3066(VarCurr,bitIndex458) )
          & ( v9775(VarNext,bitIndex37)
          <=> v3066(VarCurr,bitIndex457) )
          & ( v9775(VarNext,bitIndex36)
          <=> v3066(VarCurr,bitIndex456) )
          & ( v9775(VarNext,bitIndex35)
          <=> v3066(VarCurr,bitIndex455) )
          & ( v9775(VarNext,bitIndex34)
          <=> v3066(VarCurr,bitIndex454) )
          & ( v9775(VarNext,bitIndex33)
          <=> v3066(VarCurr,bitIndex453) )
          & ( v9775(VarNext,bitIndex32)
          <=> v3066(VarCurr,bitIndex452) )
          & ( v9775(VarNext,bitIndex31)
          <=> v3066(VarCurr,bitIndex451) )
          & ( v9775(VarNext,bitIndex30)
          <=> v3066(VarCurr,bitIndex450) )
          & ( v9775(VarNext,bitIndex29)
          <=> v3066(VarCurr,bitIndex449) )
          & ( v9775(VarNext,bitIndex28)
          <=> v3066(VarCurr,bitIndex448) )
          & ( v9775(VarNext,bitIndex27)
          <=> v3066(VarCurr,bitIndex447) )
          & ( v9775(VarNext,bitIndex26)
          <=> v3066(VarCurr,bitIndex446) )
          & ( v9775(VarNext,bitIndex25)
          <=> v3066(VarCurr,bitIndex445) )
          & ( v9775(VarNext,bitIndex24)
          <=> v3066(VarCurr,bitIndex444) )
          & ( v9775(VarNext,bitIndex23)
          <=> v3066(VarCurr,bitIndex443) )
          & ( v9775(VarNext,bitIndex22)
          <=> v3066(VarCurr,bitIndex442) )
          & ( v9775(VarNext,bitIndex21)
          <=> v3066(VarCurr,bitIndex441) )
          & ( v9775(VarNext,bitIndex20)
          <=> v3066(VarCurr,bitIndex440) )
          & ( v9775(VarNext,bitIndex19)
          <=> v3066(VarCurr,bitIndex439) )
          & ( v9775(VarNext,bitIndex18)
          <=> v3066(VarCurr,bitIndex438) )
          & ( v9775(VarNext,bitIndex17)
          <=> v3066(VarCurr,bitIndex437) )
          & ( v9775(VarNext,bitIndex16)
          <=> v3066(VarCurr,bitIndex436) )
          & ( v9775(VarNext,bitIndex15)
          <=> v3066(VarCurr,bitIndex435) )
          & ( v9775(VarNext,bitIndex14)
          <=> v3066(VarCurr,bitIndex434) )
          & ( v9775(VarNext,bitIndex13)
          <=> v3066(VarCurr,bitIndex433) )
          & ( v9775(VarNext,bitIndex12)
          <=> v3066(VarCurr,bitIndex432) )
          & ( v9775(VarNext,bitIndex11)
          <=> v3066(VarCurr,bitIndex431) )
          & ( v9775(VarNext,bitIndex10)
          <=> v3066(VarCurr,bitIndex430) )
          & ( v9775(VarNext,bitIndex9)
          <=> v3066(VarCurr,bitIndex429) )
          & ( v9775(VarNext,bitIndex8)
          <=> v3066(VarCurr,bitIndex428) )
          & ( v9775(VarNext,bitIndex7)
          <=> v3066(VarCurr,bitIndex427) )
          & ( v9775(VarNext,bitIndex6)
          <=> v3066(VarCurr,bitIndex426) )
          & ( v9775(VarNext,bitIndex5)
          <=> v3066(VarCurr,bitIndex425) )
          & ( v9775(VarNext,bitIndex4)
          <=> v3066(VarCurr,bitIndex424) )
          & ( v9775(VarNext,bitIndex3)
          <=> v3066(VarCurr,bitIndex423) )
          & ( v9775(VarNext,bitIndex2)
          <=> v3066(VarCurr,bitIndex422) )
          & ( v9775(VarNext,bitIndex1)
          <=> v3066(VarCurr,bitIndex421) )
          & ( v9775(VarNext,bitIndex0)
          <=> v3066(VarCurr,bitIndex420) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_183,axiom,
    ! [VarNext] :
      ( v9777(VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v9775(VarNext,B)
          <=> v9055(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1880,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9777(VarNext)
      <=> ( v9778(VarNext)
          & v9037(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1879,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9778(VarNext)
      <=> ( v9780(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_852,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9780(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2282,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v9021(VarCurr,B)
      <=> v9026(VarCurr,B) ) ) ).

fof(addAssignment_2281,axiom,
    ! [VarCurr] :
      ( ( v9025(VarCurr,bitIndex69)
      <=> v3066(VarCurr,bitIndex419) )
      & ( v9025(VarCurr,bitIndex68)
      <=> v3066(VarCurr,bitIndex418) )
      & ( v9025(VarCurr,bitIndex67)
      <=> v3066(VarCurr,bitIndex417) )
      & ( v9025(VarCurr,bitIndex66)
      <=> v3066(VarCurr,bitIndex416) )
      & ( v9025(VarCurr,bitIndex65)
      <=> v3066(VarCurr,bitIndex415) )
      & ( v9025(VarCurr,bitIndex64)
      <=> v3066(VarCurr,bitIndex414) )
      & ( v9025(VarCurr,bitIndex63)
      <=> v3066(VarCurr,bitIndex413) ) ) ).

fof(addAssignment_2280,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v9014(VarCurr,B)
      <=> v9019(VarCurr,B) ) ) ).

fof(addAssignment_2279,axiom,
    ! [VarCurr] :
      ( ( v9018(VarCurr,bitIndex69)
      <=> v3066(VarCurr,bitIndex489) )
      & ( v9018(VarCurr,bitIndex68)
      <=> v3066(VarCurr,bitIndex488) )
      & ( v9018(VarCurr,bitIndex67)
      <=> v3066(VarCurr,bitIndex487) )
      & ( v9018(VarCurr,bitIndex66)
      <=> v3066(VarCurr,bitIndex486) )
      & ( v9018(VarCurr,bitIndex65)
      <=> v3066(VarCurr,bitIndex485) )
      & ( v9018(VarCurr,bitIndex64)
      <=> v3066(VarCurr,bitIndex484) )
      & ( v9018(VarCurr,bitIndex63)
      <=> v3066(VarCurr,bitIndex483) ) ) ).

fof(addAssignment_2278,axiom,
    ! [VarNext] :
      ( ( v3066(VarNext,bitIndex419)
      <=> v9767(VarNext,bitIndex69) )
      & ( v3066(VarNext,bitIndex418)
      <=> v9767(VarNext,bitIndex68) )
      & ( v3066(VarNext,bitIndex417)
      <=> v9767(VarNext,bitIndex67) )
      & ( v3066(VarNext,bitIndex416)
      <=> v9767(VarNext,bitIndex66) )
      & ( v3066(VarNext,bitIndex415)
      <=> v9767(VarNext,bitIndex65) )
      & ( v3066(VarNext,bitIndex414)
      <=> v9767(VarNext,bitIndex64) )
      & ( v3066(VarNext,bitIndex413)
      <=> v9767(VarNext,bitIndex63) ) ) ).

fof(addCaseBooleanConditionShiftedRanges1_27,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9769(VarNext)
       => ( ( v9767(VarNext,bitIndex69)
          <=> v3066(VarCurr,bitIndex419) )
          & ( v9767(VarNext,bitIndex68)
          <=> v3066(VarCurr,bitIndex418) )
          & ( v9767(VarNext,bitIndex67)
          <=> v3066(VarCurr,bitIndex417) )
          & ( v9767(VarNext,bitIndex66)
          <=> v3066(VarCurr,bitIndex416) )
          & ( v9767(VarNext,bitIndex65)
          <=> v3066(VarCurr,bitIndex415) )
          & ( v9767(VarNext,bitIndex64)
          <=> v3066(VarCurr,bitIndex414) )
          & ( v9767(VarNext,bitIndex63)
          <=> v3066(VarCurr,bitIndex413) )
          & ( v9767(VarNext,bitIndex62)
          <=> v3066(VarCurr,bitIndex412) )
          & ( v9767(VarNext,bitIndex61)
          <=> v3066(VarCurr,bitIndex411) )
          & ( v9767(VarNext,bitIndex60)
          <=> v3066(VarCurr,bitIndex410) )
          & ( v9767(VarNext,bitIndex59)
          <=> v3066(VarCurr,bitIndex409) )
          & ( v9767(VarNext,bitIndex58)
          <=> v3066(VarCurr,bitIndex408) )
          & ( v9767(VarNext,bitIndex57)
          <=> v3066(VarCurr,bitIndex407) )
          & ( v9767(VarNext,bitIndex56)
          <=> v3066(VarCurr,bitIndex406) )
          & ( v9767(VarNext,bitIndex55)
          <=> v3066(VarCurr,bitIndex405) )
          & ( v9767(VarNext,bitIndex54)
          <=> v3066(VarCurr,bitIndex404) )
          & ( v9767(VarNext,bitIndex53)
          <=> v3066(VarCurr,bitIndex403) )
          & ( v9767(VarNext,bitIndex52)
          <=> v3066(VarCurr,bitIndex402) )
          & ( v9767(VarNext,bitIndex51)
          <=> v3066(VarCurr,bitIndex401) )
          & ( v9767(VarNext,bitIndex50)
          <=> v3066(VarCurr,bitIndex400) )
          & ( v9767(VarNext,bitIndex49)
          <=> v3066(VarCurr,bitIndex399) )
          & ( v9767(VarNext,bitIndex48)
          <=> v3066(VarCurr,bitIndex398) )
          & ( v9767(VarNext,bitIndex47)
          <=> v3066(VarCurr,bitIndex397) )
          & ( v9767(VarNext,bitIndex46)
          <=> v3066(VarCurr,bitIndex396) )
          & ( v9767(VarNext,bitIndex45)
          <=> v3066(VarCurr,bitIndex395) )
          & ( v9767(VarNext,bitIndex44)
          <=> v3066(VarCurr,bitIndex394) )
          & ( v9767(VarNext,bitIndex43)
          <=> v3066(VarCurr,bitIndex393) )
          & ( v9767(VarNext,bitIndex42)
          <=> v3066(VarCurr,bitIndex392) )
          & ( v9767(VarNext,bitIndex41)
          <=> v3066(VarCurr,bitIndex391) )
          & ( v9767(VarNext,bitIndex40)
          <=> v3066(VarCurr,bitIndex390) )
          & ( v9767(VarNext,bitIndex39)
          <=> v3066(VarCurr,bitIndex389) )
          & ( v9767(VarNext,bitIndex38)
          <=> v3066(VarCurr,bitIndex388) )
          & ( v9767(VarNext,bitIndex37)
          <=> v3066(VarCurr,bitIndex387) )
          & ( v9767(VarNext,bitIndex36)
          <=> v3066(VarCurr,bitIndex386) )
          & ( v9767(VarNext,bitIndex35)
          <=> v3066(VarCurr,bitIndex385) )
          & ( v9767(VarNext,bitIndex34)
          <=> v3066(VarCurr,bitIndex384) )
          & ( v9767(VarNext,bitIndex33)
          <=> v3066(VarCurr,bitIndex383) )
          & ( v9767(VarNext,bitIndex32)
          <=> v3066(VarCurr,bitIndex382) )
          & ( v9767(VarNext,bitIndex31)
          <=> v3066(VarCurr,bitIndex381) )
          & ( v9767(VarNext,bitIndex30)
          <=> v3066(VarCurr,bitIndex380) )
          & ( v9767(VarNext,bitIndex29)
          <=> v3066(VarCurr,bitIndex379) )
          & ( v9767(VarNext,bitIndex28)
          <=> v3066(VarCurr,bitIndex378) )
          & ( v9767(VarNext,bitIndex27)
          <=> v3066(VarCurr,bitIndex377) )
          & ( v9767(VarNext,bitIndex26)
          <=> v3066(VarCurr,bitIndex376) )
          & ( v9767(VarNext,bitIndex25)
          <=> v3066(VarCurr,bitIndex375) )
          & ( v9767(VarNext,bitIndex24)
          <=> v3066(VarCurr,bitIndex374) )
          & ( v9767(VarNext,bitIndex23)
          <=> v3066(VarCurr,bitIndex373) )
          & ( v9767(VarNext,bitIndex22)
          <=> v3066(VarCurr,bitIndex372) )
          & ( v9767(VarNext,bitIndex21)
          <=> v3066(VarCurr,bitIndex371) )
          & ( v9767(VarNext,bitIndex20)
          <=> v3066(VarCurr,bitIndex370) )
          & ( v9767(VarNext,bitIndex19)
          <=> v3066(VarCurr,bitIndex369) )
          & ( v9767(VarNext,bitIndex18)
          <=> v3066(VarCurr,bitIndex368) )
          & ( v9767(VarNext,bitIndex17)
          <=> v3066(VarCurr,bitIndex367) )
          & ( v9767(VarNext,bitIndex16)
          <=> v3066(VarCurr,bitIndex366) )
          & ( v9767(VarNext,bitIndex15)
          <=> v3066(VarCurr,bitIndex365) )
          & ( v9767(VarNext,bitIndex14)
          <=> v3066(VarCurr,bitIndex364) )
          & ( v9767(VarNext,bitIndex13)
          <=> v3066(VarCurr,bitIndex363) )
          & ( v9767(VarNext,bitIndex12)
          <=> v3066(VarCurr,bitIndex362) )
          & ( v9767(VarNext,bitIndex11)
          <=> v3066(VarCurr,bitIndex361) )
          & ( v9767(VarNext,bitIndex10)
          <=> v3066(VarCurr,bitIndex360) )
          & ( v9767(VarNext,bitIndex9)
          <=> v3066(VarCurr,bitIndex359) )
          & ( v9767(VarNext,bitIndex8)
          <=> v3066(VarCurr,bitIndex358) )
          & ( v9767(VarNext,bitIndex7)
          <=> v3066(VarCurr,bitIndex357) )
          & ( v9767(VarNext,bitIndex6)
          <=> v3066(VarCurr,bitIndex356) )
          & ( v9767(VarNext,bitIndex5)
          <=> v3066(VarCurr,bitIndex355) )
          & ( v9767(VarNext,bitIndex4)
          <=> v3066(VarCurr,bitIndex354) )
          & ( v9767(VarNext,bitIndex3)
          <=> v3066(VarCurr,bitIndex353) )
          & ( v9767(VarNext,bitIndex2)
          <=> v3066(VarCurr,bitIndex352) )
          & ( v9767(VarNext,bitIndex1)
          <=> v3066(VarCurr,bitIndex351) )
          & ( v9767(VarNext,bitIndex0)
          <=> v3066(VarCurr,bitIndex350) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_182,axiom,
    ! [VarNext] :
      ( v9769(VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v9767(VarNext,B)
          <=> v9009(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1878,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9769(VarNext)
      <=> ( v9770(VarNext)
          & v8991(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1877,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9770(VarNext)
      <=> ( v9772(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_851,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9772(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2277,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v8975(VarCurr,B)
      <=> v8980(VarCurr,B) ) ) ).

fof(addAssignment_2276,axiom,
    ! [VarCurr] :
      ( ( v8979(VarCurr,bitIndex69)
      <=> v3066(VarCurr,bitIndex349) )
      & ( v8979(VarCurr,bitIndex68)
      <=> v3066(VarCurr,bitIndex348) )
      & ( v8979(VarCurr,bitIndex67)
      <=> v3066(VarCurr,bitIndex347) )
      & ( v8979(VarCurr,bitIndex66)
      <=> v3066(VarCurr,bitIndex346) )
      & ( v8979(VarCurr,bitIndex65)
      <=> v3066(VarCurr,bitIndex345) )
      & ( v8979(VarCurr,bitIndex64)
      <=> v3066(VarCurr,bitIndex344) )
      & ( v8979(VarCurr,bitIndex63)
      <=> v3066(VarCurr,bitIndex343) ) ) ).

fof(addAssignment_2275,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v8968(VarCurr,B)
      <=> v8973(VarCurr,B) ) ) ).

fof(addAssignment_2274,axiom,
    ! [VarCurr] :
      ( ( v8972(VarCurr,bitIndex69)
      <=> v3066(VarCurr,bitIndex419) )
      & ( v8972(VarCurr,bitIndex68)
      <=> v3066(VarCurr,bitIndex418) )
      & ( v8972(VarCurr,bitIndex67)
      <=> v3066(VarCurr,bitIndex417) )
      & ( v8972(VarCurr,bitIndex66)
      <=> v3066(VarCurr,bitIndex416) )
      & ( v8972(VarCurr,bitIndex65)
      <=> v3066(VarCurr,bitIndex415) )
      & ( v8972(VarCurr,bitIndex64)
      <=> v3066(VarCurr,bitIndex414) )
      & ( v8972(VarCurr,bitIndex63)
      <=> v3066(VarCurr,bitIndex413) ) ) ).

fof(addAssignment_2273,axiom,
    ! [VarNext] :
      ( ( v3066(VarNext,bitIndex349)
      <=> v9759(VarNext,bitIndex69) )
      & ( v3066(VarNext,bitIndex348)
      <=> v9759(VarNext,bitIndex68) )
      & ( v3066(VarNext,bitIndex347)
      <=> v9759(VarNext,bitIndex67) )
      & ( v3066(VarNext,bitIndex346)
      <=> v9759(VarNext,bitIndex66) )
      & ( v3066(VarNext,bitIndex345)
      <=> v9759(VarNext,bitIndex65) )
      & ( v3066(VarNext,bitIndex344)
      <=> v9759(VarNext,bitIndex64) )
      & ( v3066(VarNext,bitIndex343)
      <=> v9759(VarNext,bitIndex63) ) ) ).

fof(addCaseBooleanConditionShiftedRanges1_26,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9761(VarNext)
       => ( ( v9759(VarNext,bitIndex69)
          <=> v3066(VarCurr,bitIndex349) )
          & ( v9759(VarNext,bitIndex68)
          <=> v3066(VarCurr,bitIndex348) )
          & ( v9759(VarNext,bitIndex67)
          <=> v3066(VarCurr,bitIndex347) )
          & ( v9759(VarNext,bitIndex66)
          <=> v3066(VarCurr,bitIndex346) )
          & ( v9759(VarNext,bitIndex65)
          <=> v3066(VarCurr,bitIndex345) )
          & ( v9759(VarNext,bitIndex64)
          <=> v3066(VarCurr,bitIndex344) )
          & ( v9759(VarNext,bitIndex63)
          <=> v3066(VarCurr,bitIndex343) )
          & ( v9759(VarNext,bitIndex62)
          <=> v3066(VarCurr,bitIndex342) )
          & ( v9759(VarNext,bitIndex61)
          <=> v3066(VarCurr,bitIndex341) )
          & ( v9759(VarNext,bitIndex60)
          <=> v3066(VarCurr,bitIndex340) )
          & ( v9759(VarNext,bitIndex59)
          <=> v3066(VarCurr,bitIndex339) )
          & ( v9759(VarNext,bitIndex58)
          <=> v3066(VarCurr,bitIndex338) )
          & ( v9759(VarNext,bitIndex57)
          <=> v3066(VarCurr,bitIndex337) )
          & ( v9759(VarNext,bitIndex56)
          <=> v3066(VarCurr,bitIndex336) )
          & ( v9759(VarNext,bitIndex55)
          <=> v3066(VarCurr,bitIndex335) )
          & ( v9759(VarNext,bitIndex54)
          <=> v3066(VarCurr,bitIndex334) )
          & ( v9759(VarNext,bitIndex53)
          <=> v3066(VarCurr,bitIndex333) )
          & ( v9759(VarNext,bitIndex52)
          <=> v3066(VarCurr,bitIndex332) )
          & ( v9759(VarNext,bitIndex51)
          <=> v3066(VarCurr,bitIndex331) )
          & ( v9759(VarNext,bitIndex50)
          <=> v3066(VarCurr,bitIndex330) )
          & ( v9759(VarNext,bitIndex49)
          <=> v3066(VarCurr,bitIndex329) )
          & ( v9759(VarNext,bitIndex48)
          <=> v3066(VarCurr,bitIndex328) )
          & ( v9759(VarNext,bitIndex47)
          <=> v3066(VarCurr,bitIndex327) )
          & ( v9759(VarNext,bitIndex46)
          <=> v3066(VarCurr,bitIndex326) )
          & ( v9759(VarNext,bitIndex45)
          <=> v3066(VarCurr,bitIndex325) )
          & ( v9759(VarNext,bitIndex44)
          <=> v3066(VarCurr,bitIndex324) )
          & ( v9759(VarNext,bitIndex43)
          <=> v3066(VarCurr,bitIndex323) )
          & ( v9759(VarNext,bitIndex42)
          <=> v3066(VarCurr,bitIndex322) )
          & ( v9759(VarNext,bitIndex41)
          <=> v3066(VarCurr,bitIndex321) )
          & ( v9759(VarNext,bitIndex40)
          <=> v3066(VarCurr,bitIndex320) )
          & ( v9759(VarNext,bitIndex39)
          <=> v3066(VarCurr,bitIndex319) )
          & ( v9759(VarNext,bitIndex38)
          <=> v3066(VarCurr,bitIndex318) )
          & ( v9759(VarNext,bitIndex37)
          <=> v3066(VarCurr,bitIndex317) )
          & ( v9759(VarNext,bitIndex36)
          <=> v3066(VarCurr,bitIndex316) )
          & ( v9759(VarNext,bitIndex35)
          <=> v3066(VarCurr,bitIndex315) )
          & ( v9759(VarNext,bitIndex34)
          <=> v3066(VarCurr,bitIndex314) )
          & ( v9759(VarNext,bitIndex33)
          <=> v3066(VarCurr,bitIndex313) )
          & ( v9759(VarNext,bitIndex32)
          <=> v3066(VarCurr,bitIndex312) )
          & ( v9759(VarNext,bitIndex31)
          <=> v3066(VarCurr,bitIndex311) )
          & ( v9759(VarNext,bitIndex30)
          <=> v3066(VarCurr,bitIndex310) )
          & ( v9759(VarNext,bitIndex29)
          <=> v3066(VarCurr,bitIndex309) )
          & ( v9759(VarNext,bitIndex28)
          <=> v3066(VarCurr,bitIndex308) )
          & ( v9759(VarNext,bitIndex27)
          <=> v3066(VarCurr,bitIndex307) )
          & ( v9759(VarNext,bitIndex26)
          <=> v3066(VarCurr,bitIndex306) )
          & ( v9759(VarNext,bitIndex25)
          <=> v3066(VarCurr,bitIndex305) )
          & ( v9759(VarNext,bitIndex24)
          <=> v3066(VarCurr,bitIndex304) )
          & ( v9759(VarNext,bitIndex23)
          <=> v3066(VarCurr,bitIndex303) )
          & ( v9759(VarNext,bitIndex22)
          <=> v3066(VarCurr,bitIndex302) )
          & ( v9759(VarNext,bitIndex21)
          <=> v3066(VarCurr,bitIndex301) )
          & ( v9759(VarNext,bitIndex20)
          <=> v3066(VarCurr,bitIndex300) )
          & ( v9759(VarNext,bitIndex19)
          <=> v3066(VarCurr,bitIndex299) )
          & ( v9759(VarNext,bitIndex18)
          <=> v3066(VarCurr,bitIndex298) )
          & ( v9759(VarNext,bitIndex17)
          <=> v3066(VarCurr,bitIndex297) )
          & ( v9759(VarNext,bitIndex16)
          <=> v3066(VarCurr,bitIndex296) )
          & ( v9759(VarNext,bitIndex15)
          <=> v3066(VarCurr,bitIndex295) )
          & ( v9759(VarNext,bitIndex14)
          <=> v3066(VarCurr,bitIndex294) )
          & ( v9759(VarNext,bitIndex13)
          <=> v3066(VarCurr,bitIndex293) )
          & ( v9759(VarNext,bitIndex12)
          <=> v3066(VarCurr,bitIndex292) )
          & ( v9759(VarNext,bitIndex11)
          <=> v3066(VarCurr,bitIndex291) )
          & ( v9759(VarNext,bitIndex10)
          <=> v3066(VarCurr,bitIndex290) )
          & ( v9759(VarNext,bitIndex9)
          <=> v3066(VarCurr,bitIndex289) )
          & ( v9759(VarNext,bitIndex8)
          <=> v3066(VarCurr,bitIndex288) )
          & ( v9759(VarNext,bitIndex7)
          <=> v3066(VarCurr,bitIndex287) )
          & ( v9759(VarNext,bitIndex6)
          <=> v3066(VarCurr,bitIndex286) )
          & ( v9759(VarNext,bitIndex5)
          <=> v3066(VarCurr,bitIndex285) )
          & ( v9759(VarNext,bitIndex4)
          <=> v3066(VarCurr,bitIndex284) )
          & ( v9759(VarNext,bitIndex3)
          <=> v3066(VarCurr,bitIndex283) )
          & ( v9759(VarNext,bitIndex2)
          <=> v3066(VarCurr,bitIndex282) )
          & ( v9759(VarNext,bitIndex1)
          <=> v3066(VarCurr,bitIndex281) )
          & ( v9759(VarNext,bitIndex0)
          <=> v3066(VarCurr,bitIndex280) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_181,axiom,
    ! [VarNext] :
      ( v9761(VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v9759(VarNext,B)
          <=> v8963(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1876,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9761(VarNext)
      <=> ( v9762(VarNext)
          & v8945(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1875,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9762(VarNext)
      <=> ( v9764(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_850,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9764(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2272,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v8929(VarCurr,B)
      <=> v8934(VarCurr,B) ) ) ).

fof(addAssignment_2271,axiom,
    ! [VarCurr] :
      ( ( v8933(VarCurr,bitIndex69)
      <=> v3066(VarCurr,bitIndex279) )
      & ( v8933(VarCurr,bitIndex68)
      <=> v3066(VarCurr,bitIndex278) )
      & ( v8933(VarCurr,bitIndex67)
      <=> v3066(VarCurr,bitIndex277) )
      & ( v8933(VarCurr,bitIndex66)
      <=> v3066(VarCurr,bitIndex276) )
      & ( v8933(VarCurr,bitIndex65)
      <=> v3066(VarCurr,bitIndex275) )
      & ( v8933(VarCurr,bitIndex64)
      <=> v3066(VarCurr,bitIndex274) )
      & ( v8933(VarCurr,bitIndex63)
      <=> v3066(VarCurr,bitIndex273) ) ) ).

fof(addAssignment_2270,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v8922(VarCurr,B)
      <=> v8927(VarCurr,B) ) ) ).

fof(addAssignment_2269,axiom,
    ! [VarCurr] :
      ( ( v8926(VarCurr,bitIndex69)
      <=> v3066(VarCurr,bitIndex349) )
      & ( v8926(VarCurr,bitIndex68)
      <=> v3066(VarCurr,bitIndex348) )
      & ( v8926(VarCurr,bitIndex67)
      <=> v3066(VarCurr,bitIndex347) )
      & ( v8926(VarCurr,bitIndex66)
      <=> v3066(VarCurr,bitIndex346) )
      & ( v8926(VarCurr,bitIndex65)
      <=> v3066(VarCurr,bitIndex345) )
      & ( v8926(VarCurr,bitIndex64)
      <=> v3066(VarCurr,bitIndex344) )
      & ( v8926(VarCurr,bitIndex63)
      <=> v3066(VarCurr,bitIndex343) ) ) ).

fof(addAssignment_2268,axiom,
    ! [VarNext] :
      ( ( v3066(VarNext,bitIndex279)
      <=> v9751(VarNext,bitIndex69) )
      & ( v3066(VarNext,bitIndex278)
      <=> v9751(VarNext,bitIndex68) )
      & ( v3066(VarNext,bitIndex277)
      <=> v9751(VarNext,bitIndex67) )
      & ( v3066(VarNext,bitIndex276)
      <=> v9751(VarNext,bitIndex66) )
      & ( v3066(VarNext,bitIndex275)
      <=> v9751(VarNext,bitIndex65) )
      & ( v3066(VarNext,bitIndex274)
      <=> v9751(VarNext,bitIndex64) )
      & ( v3066(VarNext,bitIndex273)
      <=> v9751(VarNext,bitIndex63) ) ) ).

fof(addCaseBooleanConditionShiftedRanges1_25,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9753(VarNext)
       => ( ( v9751(VarNext,bitIndex69)
          <=> v3066(VarCurr,bitIndex279) )
          & ( v9751(VarNext,bitIndex68)
          <=> v3066(VarCurr,bitIndex278) )
          & ( v9751(VarNext,bitIndex67)
          <=> v3066(VarCurr,bitIndex277) )
          & ( v9751(VarNext,bitIndex66)
          <=> v3066(VarCurr,bitIndex276) )
          & ( v9751(VarNext,bitIndex65)
          <=> v3066(VarCurr,bitIndex275) )
          & ( v9751(VarNext,bitIndex64)
          <=> v3066(VarCurr,bitIndex274) )
          & ( v9751(VarNext,bitIndex63)
          <=> v3066(VarCurr,bitIndex273) )
          & ( v9751(VarNext,bitIndex62)
          <=> v3066(VarCurr,bitIndex272) )
          & ( v9751(VarNext,bitIndex61)
          <=> v3066(VarCurr,bitIndex271) )
          & ( v9751(VarNext,bitIndex60)
          <=> v3066(VarCurr,bitIndex270) )
          & ( v9751(VarNext,bitIndex59)
          <=> v3066(VarCurr,bitIndex269) )
          & ( v9751(VarNext,bitIndex58)
          <=> v3066(VarCurr,bitIndex268) )
          & ( v9751(VarNext,bitIndex57)
          <=> v3066(VarCurr,bitIndex267) )
          & ( v9751(VarNext,bitIndex56)
          <=> v3066(VarCurr,bitIndex266) )
          & ( v9751(VarNext,bitIndex55)
          <=> v3066(VarCurr,bitIndex265) )
          & ( v9751(VarNext,bitIndex54)
          <=> v3066(VarCurr,bitIndex264) )
          & ( v9751(VarNext,bitIndex53)
          <=> v3066(VarCurr,bitIndex263) )
          & ( v9751(VarNext,bitIndex52)
          <=> v3066(VarCurr,bitIndex262) )
          & ( v9751(VarNext,bitIndex51)
          <=> v3066(VarCurr,bitIndex261) )
          & ( v9751(VarNext,bitIndex50)
          <=> v3066(VarCurr,bitIndex260) )
          & ( v9751(VarNext,bitIndex49)
          <=> v3066(VarCurr,bitIndex259) )
          & ( v9751(VarNext,bitIndex48)
          <=> v3066(VarCurr,bitIndex258) )
          & ( v9751(VarNext,bitIndex47)
          <=> v3066(VarCurr,bitIndex257) )
          & ( v9751(VarNext,bitIndex46)
          <=> v3066(VarCurr,bitIndex256) )
          & ( v9751(VarNext,bitIndex45)
          <=> v3066(VarCurr,bitIndex255) )
          & ( v9751(VarNext,bitIndex44)
          <=> v3066(VarCurr,bitIndex254) )
          & ( v9751(VarNext,bitIndex43)
          <=> v3066(VarCurr,bitIndex253) )
          & ( v9751(VarNext,bitIndex42)
          <=> v3066(VarCurr,bitIndex252) )
          & ( v9751(VarNext,bitIndex41)
          <=> v3066(VarCurr,bitIndex251) )
          & ( v9751(VarNext,bitIndex40)
          <=> v3066(VarCurr,bitIndex250) )
          & ( v9751(VarNext,bitIndex39)
          <=> v3066(VarCurr,bitIndex249) )
          & ( v9751(VarNext,bitIndex38)
          <=> v3066(VarCurr,bitIndex248) )
          & ( v9751(VarNext,bitIndex37)
          <=> v3066(VarCurr,bitIndex247) )
          & ( v9751(VarNext,bitIndex36)
          <=> v3066(VarCurr,bitIndex246) )
          & ( v9751(VarNext,bitIndex35)
          <=> v3066(VarCurr,bitIndex245) )
          & ( v9751(VarNext,bitIndex34)
          <=> v3066(VarCurr,bitIndex244) )
          & ( v9751(VarNext,bitIndex33)
          <=> v3066(VarCurr,bitIndex243) )
          & ( v9751(VarNext,bitIndex32)
          <=> v3066(VarCurr,bitIndex242) )
          & ( v9751(VarNext,bitIndex31)
          <=> v3066(VarCurr,bitIndex241) )
          & ( v9751(VarNext,bitIndex30)
          <=> v3066(VarCurr,bitIndex240) )
          & ( v9751(VarNext,bitIndex29)
          <=> v3066(VarCurr,bitIndex239) )
          & ( v9751(VarNext,bitIndex28)
          <=> v3066(VarCurr,bitIndex238) )
          & ( v9751(VarNext,bitIndex27)
          <=> v3066(VarCurr,bitIndex237) )
          & ( v9751(VarNext,bitIndex26)
          <=> v3066(VarCurr,bitIndex236) )
          & ( v9751(VarNext,bitIndex25)
          <=> v3066(VarCurr,bitIndex235) )
          & ( v9751(VarNext,bitIndex24)
          <=> v3066(VarCurr,bitIndex234) )
          & ( v9751(VarNext,bitIndex23)
          <=> v3066(VarCurr,bitIndex233) )
          & ( v9751(VarNext,bitIndex22)
          <=> v3066(VarCurr,bitIndex232) )
          & ( v9751(VarNext,bitIndex21)
          <=> v3066(VarCurr,bitIndex231) )
          & ( v9751(VarNext,bitIndex20)
          <=> v3066(VarCurr,bitIndex230) )
          & ( v9751(VarNext,bitIndex19)
          <=> v3066(VarCurr,bitIndex229) )
          & ( v9751(VarNext,bitIndex18)
          <=> v3066(VarCurr,bitIndex228) )
          & ( v9751(VarNext,bitIndex17)
          <=> v3066(VarCurr,bitIndex227) )
          & ( v9751(VarNext,bitIndex16)
          <=> v3066(VarCurr,bitIndex226) )
          & ( v9751(VarNext,bitIndex15)
          <=> v3066(VarCurr,bitIndex225) )
          & ( v9751(VarNext,bitIndex14)
          <=> v3066(VarCurr,bitIndex224) )
          & ( v9751(VarNext,bitIndex13)
          <=> v3066(VarCurr,bitIndex223) )
          & ( v9751(VarNext,bitIndex12)
          <=> v3066(VarCurr,bitIndex222) )
          & ( v9751(VarNext,bitIndex11)
          <=> v3066(VarCurr,bitIndex221) )
          & ( v9751(VarNext,bitIndex10)
          <=> v3066(VarCurr,bitIndex220) )
          & ( v9751(VarNext,bitIndex9)
          <=> v3066(VarCurr,bitIndex219) )
          & ( v9751(VarNext,bitIndex8)
          <=> v3066(VarCurr,bitIndex218) )
          & ( v9751(VarNext,bitIndex7)
          <=> v3066(VarCurr,bitIndex217) )
          & ( v9751(VarNext,bitIndex6)
          <=> v3066(VarCurr,bitIndex216) )
          & ( v9751(VarNext,bitIndex5)
          <=> v3066(VarCurr,bitIndex215) )
          & ( v9751(VarNext,bitIndex4)
          <=> v3066(VarCurr,bitIndex214) )
          & ( v9751(VarNext,bitIndex3)
          <=> v3066(VarCurr,bitIndex213) )
          & ( v9751(VarNext,bitIndex2)
          <=> v3066(VarCurr,bitIndex212) )
          & ( v9751(VarNext,bitIndex1)
          <=> v3066(VarCurr,bitIndex211) )
          & ( v9751(VarNext,bitIndex0)
          <=> v3066(VarCurr,bitIndex210) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_180,axiom,
    ! [VarNext] :
      ( v9753(VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v9751(VarNext,B)
          <=> v8917(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1874,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9753(VarNext)
      <=> ( v9754(VarNext)
          & v8898(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1873,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9754(VarNext)
      <=> ( v9756(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_849,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9756(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2267,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v8882(VarCurr,B)
      <=> v8887(VarCurr,B) ) ) ).

fof(addAssignment_2266,axiom,
    ! [VarCurr] :
      ( ( v8886(VarCurr,bitIndex69)
      <=> v3066(VarCurr,bitIndex209) )
      & ( v8886(VarCurr,bitIndex68)
      <=> v3066(VarCurr,bitIndex208) )
      & ( v8886(VarCurr,bitIndex67)
      <=> v3066(VarCurr,bitIndex207) )
      & ( v8886(VarCurr,bitIndex66)
      <=> v3066(VarCurr,bitIndex206) )
      & ( v8886(VarCurr,bitIndex65)
      <=> v3066(VarCurr,bitIndex205) )
      & ( v8886(VarCurr,bitIndex64)
      <=> v3066(VarCurr,bitIndex204) )
      & ( v8886(VarCurr,bitIndex63)
      <=> v3066(VarCurr,bitIndex203) ) ) ).

fof(addAssignment_2265,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v3069(VarCurr,B)
      <=> v8880(VarCurr,B) ) ) ).

fof(addAssignment_2264,axiom,
    ! [VarCurr] :
      ( ( v8871(VarCurr,bitIndex69)
      <=> v3066(VarCurr,bitIndex279) )
      & ( v8871(VarCurr,bitIndex68)
      <=> v3066(VarCurr,bitIndex278) )
      & ( v8871(VarCurr,bitIndex67)
      <=> v3066(VarCurr,bitIndex277) )
      & ( v8871(VarCurr,bitIndex66)
      <=> v3066(VarCurr,bitIndex276) )
      & ( v8871(VarCurr,bitIndex65)
      <=> v3066(VarCurr,bitIndex275) )
      & ( v8871(VarCurr,bitIndex64)
      <=> v3066(VarCurr,bitIndex274) )
      & ( v8871(VarCurr,bitIndex63)
      <=> v3066(VarCurr,bitIndex273) ) ) ).

fof(addAssignment_2263,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v3163(VarCurr,B)
      <=> v3165(VarCurr,B) ) ) ).

fof(addAssignment_2262,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v3165(VarCurr,B)
      <=> v3167(VarCurr,B) ) ) ).

fof(addAssignment_2261,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v3167(VarCurr,B)
      <=> v3169(VarCurr,B) ) ) ).

fof(addAssignment_2260,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v3169(VarCurr,B)
      <=> v3171(VarCurr,B) ) ) ).

fof(addAssignment_2259,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v3171(VarCurr,B)
      <=> v3173(VarCurr,B) ) ) ).

fof(addAssignment_2258,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v3173(VarCurr,B)
      <=> v3175(VarCurr,B) ) ) ).

fof(addAssignment_2257,axiom,
    ! [VarCurr,B] :
      ( range_69_63(B)
     => ( v3175(VarCurr,B)
      <=> v8859(VarCurr,B) ) ) ).

fof(range_axiom_54,axiom,
    ! [B] :
      ( range_69_63(B)
    <=> ( $false
        | bitIndex63 = B
        | bitIndex64 = B
        | bitIndex65 = B
        | bitIndex66 = B
        | bitIndex67 = B
        | bitIndex68 = B
        | bitIndex69 = B ) ) ).

fof(addCaseBooleanConditionEqualRanges1_163,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9718(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v8860(VarNext,B)
            <=> v8860(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_179,axiom,
    ! [VarNext] :
      ( v9718(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v8860(VarNext,B)
          <=> v9745(VarNext,B) ) ) ) ).

fof(addAssignment_2256,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v9745(VarNext,B)
          <=> v9743(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_266,axiom,
    ! [VarCurr] :
      ( ~ v8824(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v9743(VarCurr,B)
          <=> v9746(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_254,axiom,
    ! [VarCurr] :
      ( v8824(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v9743(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_265,axiom,
    ! [VarCurr] :
      ( ~ v8827(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v9746(VarCurr,B)
          <=> v6576(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_253,axiom,
    ! [VarCurr] :
      ( v8827(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v9746(VarCurr,B)
          <=> v9747(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges1_2,axiom,
    ! [VarCurr] :
      ( ~ v8838(VarCurr)
     => ( ( v9747(VarCurr,bitIndex6)
        <=> v6553(VarCurr,bitIndex53) )
        & ( v9747(VarCurr,bitIndex5)
        <=> v6553(VarCurr,bitIndex52) )
        & ( v9747(VarCurr,bitIndex4)
        <=> v6553(VarCurr,bitIndex51) )
        & ( v9747(VarCurr,bitIndex3)
        <=> v6553(VarCurr,bitIndex50) )
        & ( v9747(VarCurr,bitIndex2)
        <=> v6553(VarCurr,bitIndex49) )
        & ( v9747(VarCurr,bitIndex1)
        <=> v6553(VarCurr,bitIndex48) )
        & ( v9747(VarCurr,bitIndex0)
        <=> v6553(VarCurr,bitIndex47) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_252,axiom,
    ! [VarCurr] :
      ( v8838(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v9747(VarCurr,B)
          <=> v6576(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1872,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9718(VarNext)
      <=> ( v9719(VarNext)
          & v9726(VarNext) ) ) ) ).

fof(addAssignment_2255,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9726(VarNext)
      <=> v9724(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1871,axiom,
    ! [VarCurr] :
      ( v9724(VarCurr)
    <=> ( v9727(VarCurr)
        & v9731(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1870,axiom,
    ! [VarCurr] :
      ( v9731(VarCurr)
    <=> ( v9732(VarCurr)
        | v8824(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1869,axiom,
    ! [VarCurr] :
      ( v9732(VarCurr)
    <=> ( v9733(VarCurr)
        & v9741(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1868,axiom,
    ! [VarCurr] :
      ( v9741(VarCurr)
    <=> ( v9742(VarCurr)
        | v8828(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1867,axiom,
    ! [VarCurr] :
      ( v9742(VarCurr)
    <=> ( v8835(VarCurr)
        | v8827(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1866,axiom,
    ! [VarCurr] :
      ( v9733(VarCurr)
    <=> ( v9734(VarCurr)
        & v9739(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1865,axiom,
    ! [VarCurr] :
      ( v9739(VarCurr)
    <=> ( v56(VarCurr)
        | v9740(VarCurr) ) ) ).

fof(writeUnaryOperator_848,axiom,
    ! [VarCurr] :
      ( ~ v9740(VarCurr)
    <=> v8828(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1864,axiom,
    ! [VarCurr] :
      ( v9734(VarCurr)
    <=> ( v9735(VarCurr)
        & v9736(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1863,axiom,
    ! [VarCurr] :
      ( v9736(VarCurr)
    <=> ( v9737(VarCurr)
        | v9738(VarCurr) ) ) ).

fof(writeUnaryOperator_847,axiom,
    ! [VarCurr] :
      ( ~ v9738(VarCurr)
    <=> v8827(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1862,axiom,
    ! [VarCurr] :
      ( v9737(VarCurr)
    <=> ( v8838(VarCurr)
        | v8840(VarCurr) ) ) ).

fof(writeUnaryOperator_846,axiom,
    ! [VarCurr] :
      ( ~ v9735(VarCurr)
    <=> v8835(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1861,axiom,
    ! [VarCurr] :
      ( v9727(VarCurr)
    <=> ( v8824(VarCurr)
        | v9728(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1860,axiom,
    ! [VarCurr] :
      ( v9728(VarCurr)
    <=> ( v9729(VarCurr)
        & v9730(VarCurr) ) ) ).

fof(writeUnaryOperator_845,axiom,
    ! [VarCurr] :
      ( ~ v9730(VarCurr)
    <=> v8824(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1859,axiom,
    ! [VarCurr] :
      ( v9729(VarCurr)
    <=> ( v8827(VarCurr)
        | v8828(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1858,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9719(VarNext)
      <=> ( v9721(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_844,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9721(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignment_2254,axiom,
    ! [VarCurr,B] :
      ( range_53_47(B)
     => ( v6553(VarCurr,B)
      <=> v6555(VarCurr,B) ) ) ).

fof(addAssignment_2253,axiom,
    ! [VarCurr,B] :
      ( range_53_47(B)
     => ( v6555(VarCurr,B)
      <=> v6557(VarCurr,B) ) ) ).

fof(addAssignment_2252,axiom,
    ! [VarCurr,B] :
      ( range_53_47(B)
     => ( v6557(VarCurr,B)
      <=> v6559(VarCurr,B) ) ) ).

fof(addAssignment_2251,axiom,
    ! [VarCurr,B] :
      ( range_53_47(B)
     => ( v6559(VarCurr,B)
      <=> v7082(VarCurr,B) ) ) ).

fof(range_axiom_53,axiom,
    ! [B] :
      ( range_53_47(B)
    <=> ( $false
        | bitIndex47 = B
        | bitIndex48 = B
        | bitIndex49 = B
        | bitIndex50 = B
        | bitIndex51 = B
        | bitIndex52 = B
        | bitIndex53 = B ) ) ).

fof(addAssignment_2250,axiom,
    ! [VarCurr] :
      ( v29(VarCurr)
    <=> v31(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_162,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9692(VarNext)
       => ( v31(VarNext)
        <=> v31(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_178,axiom,
    ! [VarNext] :
      ( v9692(VarNext)
     => ( v31(VarNext)
      <=> v9710(VarNext) ) ) ).

fof(addAssignment_2249,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9710(VarNext)
      <=> v9708(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_255,axiom,
    ! [VarCurr] :
      ( ~ v9707(VarCurr)
     => ( v9708(VarCurr)
      <=> v9711(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_259,axiom,
    ! [VarCurr] :
      ( v9707(VarCurr)
     => ( v9708(VarCurr)
      <=> $true ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_254,axiom,
    ! [VarCurr] :
      ( ~ v37(VarCurr)
     => ( v9711(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_258,axiom,
    ! [VarCurr] :
      ( v37(VarCurr)
     => ( v9711(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1857,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9692(VarNext)
      <=> ( v9693(VarNext)
          & v9700(VarNext) ) ) ) ).

fof(addAssignment_2248,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9700(VarNext)
      <=> v9698(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1856,axiom,
    ! [VarCurr] :
      ( v9698(VarCurr)
    <=> ( v9701(VarCurr)
        | v9707(VarCurr) ) ) ).

fof(writeUnaryOperator_843,axiom,
    ! [VarCurr] :
      ( ~ v9707(VarCurr)
    <=> v33(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1855,axiom,
    ! [VarCurr] :
      ( v9701(VarCurr)
    <=> ( v9702(VarCurr)
        | v37(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1854,axiom,
    ! [VarCurr] :
      ( v9702(VarCurr)
    <=> ( v9703(VarCurr)
        & v9706(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_724,axiom,
    ! [VarCurr] :
      ( v9706(VarCurr)
    <=> ( v3075(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1853,axiom,
    ! [VarCurr] :
      ( v9703(VarCurr)
    <=> ( v9704(VarCurr)
        & v9705(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_723,axiom,
    ! [VarCurr] :
      ( v9705(VarCurr)
    <=> ( v2975(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_722,axiom,
    ! [VarCurr] :
      ( v9704(VarCurr)
    <=> ( v2980(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1852,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9693(VarNext)
      <=> ( v9694(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_842,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9694(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2247,axiom,
    ! [VarCurr] :
      ( v3075(VarCurr,bitIndex0)
    <=> v3105(VarCurr,bitIndex0) ) ).

fof(addAssignment_2246,axiom,
    ! [VarCurr] :
      ( v37(VarCurr)
    <=> v39(VarCurr) ) ).

fof(addAssignment_2245,axiom,
    ! [VarCurr] :
      ( v39(VarCurr)
    <=> v41(VarCurr) ) ).

fof(addAssignment_2244,axiom,
    ! [VarCurr] :
      ( v41(VarCurr)
    <=> v43(VarCurr) ) ).

fof(addAssignment_2243,axiom,
    ! [VarCurr] :
      ( v43(VarCurr)
    <=> v45(VarCurr) ) ).

fof(addAssignment_2242,axiom,
    ! [VarCurr] :
      ( v45(VarCurr)
    <=> v47(VarCurr) ) ).

fof(addAssignment_2241,axiom,
    ! [VarCurr] :
      ( v47(VarCurr)
    <=> v49(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_161,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9679(VarNext)
       => ( v49(VarNext)
        <=> v49(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_177,axiom,
    ! [VarNext] :
      ( v9679(VarNext)
     => ( v49(VarNext)
      <=> v9687(VarNext) ) ) ).

fof(addAssignment_2240,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9687(VarNext)
      <=> v9685(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_253,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ( v9685(VarCurr)
      <=> v56(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_257,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ( v9685(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1851,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9679(VarNext)
      <=> v9680(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1850,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9680(VarNext)
      <=> ( v9682(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_841,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9682(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_48,axiom,
    ! [VarCurr] :
      ( ( ~ v8711(VarCurr)
        & ~ v8712(VarCurr)
        & ~ v8743(VarCurr) )
     => ( v56(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_103,axiom,
    ! [VarCurr] :
      ( v8743(VarCurr)
     => ( v56(VarCurr)
      <=> v9676(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_264,axiom,
    ! [VarCurr] :
      ( v8712(VarCurr)
     => ( v56(VarCurr)
      <=> v9670(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_251,axiom,
    ! [VarCurr] :
      ( v8711(VarCurr)
     => ( v56(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_263,axiom,
    ! [VarCurr] :
      ( ~ v9582(VarCurr)
     => ( v9676(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_250,axiom,
    ! [VarCurr] :
      ( v9582(VarCurr)
     => ( v9676(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_262,axiom,
    ! [VarCurr] :
      ( ~ v8714(VarCurr)
     => ( v9670(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_249,axiom,
    ! [VarCurr] :
      ( v8714(VarCurr)
     => ( v9670(VarCurr)
      <=> v9671(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_47,axiom,
    ! [VarCurr] :
      ( ( ~ v8716(VarCurr)
        & ~ v8718(VarCurr)
        & ~ v8732(VarCurr) )
     => ( v9671(VarCurr)
      <=> v9674(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_102,axiom,
    ! [VarCurr] :
      ( v8732(VarCurr)
     => ( v9671(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_261,axiom,
    ! [VarCurr] :
      ( v8718(VarCurr)
     => ( v9671(VarCurr)
      <=> v9672(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_248,axiom,
    ! [VarCurr] :
      ( v8716(VarCurr)
     => ( v9671(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_260,axiom,
    ! [VarCurr] :
      ( ~ v8737(VarCurr)
     => ( v9674(VarCurr)
      <=> v9675(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_247,axiom,
    ! [VarCurr] :
      ( v8737(VarCurr)
     => ( v9674(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_259,axiom,
    ! [VarCurr] :
      ( ~ v8740(VarCurr)
     => ( v9675(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_246,axiom,
    ! [VarCurr] :
      ( v8740(VarCurr)
     => ( v9675(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_258,axiom,
    ! [VarCurr] :
      ( ~ v9673(VarCurr)
     => ( v9672(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_245,axiom,
    ! [VarCurr] :
      ( v9673(VarCurr)
     => ( v9672(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1849,axiom,
    ! [VarCurr] :
      ( v9673(VarCurr)
    <=> ( v8722(VarCurr)
        | v8727(VarCurr) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_160,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9657(VarNext)
       => ! [B] :
            ( range_2_0(B)
           => ( v58(VarNext,B)
            <=> v58(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_176,axiom,
    ! [VarNext] :
      ( v9657(VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v58(VarNext,B)
          <=> v9665(VarNext,B) ) ) ) ).

fof(addAssignment_2239,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v9665(VarNext,B)
          <=> v9663(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_252,axiom,
    ! [VarCurr] :
      ( ~ v9666(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9663(VarCurr,B)
          <=> v61(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_256,axiom,
    ! [VarCurr] :
      ( v9666(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9663(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_721,axiom,
    ! [VarCurr] :
      ( v9666(VarCurr)
    <=> ( v51(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1848,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9657(VarNext)
      <=> v9658(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1847,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9658(VarNext)
      <=> ( v9659(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_840,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9659(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_46,axiom,
    ! [VarCurr] :
      ( ( ~ v9602(VarCurr)
        & ~ v9615(VarCurr)
        & ~ v9651(VarCurr) )
     => ! [B] :
          ( range_2_0(B)
         => ( v61(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_101,axiom,
    ! [VarCurr] :
      ( v9651(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v61(VarCurr,B)
          <=> v9652(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_257,axiom,
    ! [VarCurr] :
      ( v9615(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v61(VarCurr,B)
          <=> v9616(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_244,axiom,
    ! [VarCurr] :
      ( v9602(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v61(VarCurr,B)
          <=> v9603(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_256,axiom,
    ! [VarCurr] :
      ( ~ v9653(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9652(VarCurr,B)
          <=> b011(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_243,axiom,
    ! [VarCurr] :
      ( v9653(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9652(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_720,axiom,
    ! [VarCurr] :
      ( v9654(VarCurr)
    <=> ( v2961(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_719,axiom,
    ! [VarCurr] :
      ( v9653(VarCurr)
    <=> ( v2961(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_718,axiom,
    ! [VarCurr] :
      ( v9651(VarCurr)
    <=> ( ( v58(VarCurr,bitIndex2)
        <=> $false )
        & ( v58(VarCurr,bitIndex1)
        <=> $true )
        & ( v58(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_255,axiom,
    ! [VarCurr] :
      ( ~ v9617(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9616(VarCurr,B)
          <=> b010(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_242,axiom,
    ! [VarCurr] :
      ( v9617(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9616(VarCurr,B)
          <=> v9618(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_717,axiom,
    ! [VarCurr] :
      ( v9650(VarCurr)
    <=> ( v2961(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_45,axiom,
    ! [VarCurr] :
      ( ( ~ v9619(VarCurr)
        & ~ v9624(VarCurr)
        & ~ v9637(VarCurr) )
     => ! [B] :
          ( range_2_0(B)
         => ( v9618(VarCurr,B)
          <=> v9644(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_100,axiom,
    ! [VarCurr] :
      ( v9637(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9618(VarCurr,B)
          <=> v9639(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_254,axiom,
    ! [VarCurr] :
      ( v9624(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9618(VarCurr,B)
          <=> v9626(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_241,axiom,
    ! [VarCurr] :
      ( v9619(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9618(VarCurr,B)
          <=> v9621(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_253,axiom,
    ! [VarCurr] :
      ( ~ v9645(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9644(VarCurr,B)
          <=> v9647(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_240,axiom,
    ! [VarCurr] :
      ( v9645(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9644(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_252,axiom,
    ! [VarCurr] :
      ( ~ v9648(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9647(VarCurr,B)
          <=> b010(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_239,axiom,
    ! [VarCurr] :
      ( v9648(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9647(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_716,axiom,
    ! [VarCurr] :
      ( v9649(VarCurr)
    <=> ( v8673(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_715,axiom,
    ! [VarCurr] :
      ( v9648(VarCurr)
    <=> ( v8673(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_714,axiom,
    ! [VarCurr] :
      ( v9646(VarCurr)
    <=> ( v5623(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_713,axiom,
    ! [VarCurr] :
      ( v9645(VarCurr)
    <=> ( v5623(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_712,axiom,
    ! [VarCurr] :
      ( v9642(VarCurr)
    <=> ( ( v9643(VarCurr,bitIndex1)
        <=> $true )
        & ( v9643(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2238,axiom,
    ! [VarCurr] :
      ( v9643(VarCurr,bitIndex0)
    <=> v8704(VarCurr) ) ).

fof(addAssignment_2237,axiom,
    ! [VarCurr] :
      ( v9643(VarCurr,bitIndex1)
    <=> v3182(VarCurr) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_251,axiom,
    ! [VarCurr] :
      ( ~ v9640(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9639(VarCurr,B)
          <=> b010(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_238,axiom,
    ! [VarCurr] :
      ( v9640(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9639(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_711,axiom,
    ! [VarCurr] :
      ( v9641(VarCurr)
    <=> ( v8673(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_710,axiom,
    ! [VarCurr] :
      ( v9640(VarCurr)
    <=> ( v8673(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_709,axiom,
    ! [VarCurr] :
      ( v9637(VarCurr)
    <=> ( ( v9638(VarCurr,bitIndex1)
        <=> $true )
        & ( v9638(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2236,axiom,
    ! [VarCurr] :
      ( v9638(VarCurr,bitIndex0)
    <=> v8704(VarCurr) ) ).

fof(addAssignment_2235,axiom,
    ! [VarCurr] :
      ( v9638(VarCurr,bitIndex1)
    <=> v3182(VarCurr) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_99,axiom,
    ! [VarCurr] :
      ( ( ~ v9627(VarCurr)
        & ~ v9632(VarCurr) )
     => ! [B] :
          ( range_2_0(B)
         => ( v9626(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_250,axiom,
    ! [VarCurr] :
      ( v9632(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9626(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_237,axiom,
    ! [VarCurr] :
      ( v9627(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9626(VarCurr,B)
          <=> b010(B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1846,axiom,
    ! [VarCurr] :
      ( v9632(VarCurr)
    <=> ( v9633(VarCurr)
        | v9635(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_708,axiom,
    ! [VarCurr] :
      ( v9635(VarCurr)
    <=> ( ( v9636(VarCurr,bitIndex3)
        <=> $false )
        & ( v9636(VarCurr,bitIndex2)
        <=> $true )
        & ( v9636(VarCurr,bitIndex1)
        <=> $false )
        & ( v9636(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2234,axiom,
    ! [VarCurr] :
      ( v9636(VarCurr,bitIndex0)
    <=> v6632(VarCurr) ) ).

fof(addAssignment_2233,axiom,
    ! [VarCurr] :
      ( ( v9636(VarCurr,bitIndex3)
      <=> v4672(VarCurr,bitIndex2) )
      & ( v9636(VarCurr,bitIndex2)
      <=> v4672(VarCurr,bitIndex1) )
      & ( v9636(VarCurr,bitIndex1)
      <=> v4672(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_707,axiom,
    ! [VarCurr] :
      ( v9633(VarCurr)
    <=> ( ( v9634(VarCurr,bitIndex3)
        <=> $false )
        & ( v9634(VarCurr,bitIndex2)
        <=> $false )
        & ( v9634(VarCurr,bitIndex1)
        <=> $true )
        & ( v9634(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2232,axiom,
    ! [VarCurr] :
      ( v9634(VarCurr,bitIndex0)
    <=> v6632(VarCurr) ) ).

fof(addAssignment_2231,axiom,
    ! [VarCurr] :
      ( ( v9634(VarCurr,bitIndex3)
      <=> v4672(VarCurr,bitIndex2) )
      & ( v9634(VarCurr,bitIndex2)
      <=> v4672(VarCurr,bitIndex1) )
      & ( v9634(VarCurr,bitIndex1)
      <=> v4672(VarCurr,bitIndex0) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1845,axiom,
    ! [VarCurr] :
      ( v9627(VarCurr)
    <=> ( v9628(VarCurr)
        | v9630(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_706,axiom,
    ! [VarCurr] :
      ( v9630(VarCurr)
    <=> ( ( v9631(VarCurr,bitIndex3)
        <=> $false )
        & ( v9631(VarCurr,bitIndex2)
        <=> $true )
        & ( v9631(VarCurr,bitIndex1)
        <=> $false )
        & ( v9631(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2230,axiom,
    ! [VarCurr] :
      ( v9631(VarCurr,bitIndex0)
    <=> v6632(VarCurr) ) ).

fof(addAssignment_2229,axiom,
    ! [VarCurr] :
      ( ( v9631(VarCurr,bitIndex3)
      <=> v4672(VarCurr,bitIndex2) )
      & ( v9631(VarCurr,bitIndex2)
      <=> v4672(VarCurr,bitIndex1) )
      & ( v9631(VarCurr,bitIndex1)
      <=> v4672(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_705,axiom,
    ! [VarCurr] :
      ( v9628(VarCurr)
    <=> ( ( v9629(VarCurr,bitIndex3)
        <=> $false )
        & ( v9629(VarCurr,bitIndex2)
        <=> $false )
        & ( v9629(VarCurr,bitIndex1)
        <=> $true )
        & ( v9629(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2228,axiom,
    ! [VarCurr] :
      ( v9629(VarCurr,bitIndex0)
    <=> v6632(VarCurr) ) ).

fof(addAssignment_2227,axiom,
    ! [VarCurr] :
      ( ( v9629(VarCurr,bitIndex3)
      <=> v4672(VarCurr,bitIndex2) )
      & ( v9629(VarCurr,bitIndex2)
      <=> v4672(VarCurr,bitIndex1) )
      & ( v9629(VarCurr,bitIndex1)
      <=> v4672(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_704,axiom,
    ! [VarCurr] :
      ( v9624(VarCurr)
    <=> ( ( v9625(VarCurr,bitIndex1)
        <=> $false )
        & ( v9625(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2226,axiom,
    ! [VarCurr] :
      ( v9625(VarCurr,bitIndex0)
    <=> v8704(VarCurr) ) ).

fof(addAssignment_2225,axiom,
    ! [VarCurr] :
      ( v9625(VarCurr,bitIndex1)
    <=> v3182(VarCurr) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_249,axiom,
    ! [VarCurr] :
      ( ~ v9622(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9621(VarCurr,B)
          <=> b010(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_236,axiom,
    ! [VarCurr] :
      ( v9622(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9621(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_703,axiom,
    ! [VarCurr] :
      ( v9623(VarCurr)
    <=> ( v8673(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_702,axiom,
    ! [VarCurr] :
      ( v9622(VarCurr)
    <=> ( v8673(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_701,axiom,
    ! [VarCurr] :
      ( v9619(VarCurr)
    <=> ( ( v9620(VarCurr,bitIndex1)
        <=> $false )
        & ( v9620(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2224,axiom,
    ! [VarCurr] :
      ( v9620(VarCurr,bitIndex0)
    <=> v8704(VarCurr) ) ).

fof(addAssignment_2223,axiom,
    ! [VarCurr] :
      ( v9620(VarCurr,bitIndex1)
    <=> v3182(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_700,axiom,
    ! [VarCurr] :
      ( v9617(VarCurr)
    <=> ( v2961(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_699,axiom,
    ! [VarCurr] :
      ( v9615(VarCurr)
    <=> ( ( v58(VarCurr,bitIndex2)
        <=> $false )
        & ( v58(VarCurr,bitIndex1)
        <=> $true )
        & ( v58(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_248,axiom,
    ! [VarCurr] :
      ( ~ v9604(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9603(VarCurr,B)
          <=> v9606(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_235,axiom,
    ! [VarCurr] :
      ( v9604(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9603(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_98,axiom,
    ! [VarCurr] :
      ( ( ~ v9607(VarCurr)
        & ~ v9612(VarCurr) )
     => ! [B] :
          ( range_2_0(B)
         => ( v9606(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_247,axiom,
    ! [VarCurr] :
      ( v9612(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9606(VarCurr,B)
          <=> b010(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_234,axiom,
    ! [VarCurr] :
      ( v9607(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9606(VarCurr,B)
          <=> b011(B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1844,axiom,
    ! [VarCurr] :
      ( v9612(VarCurr)
    <=> ( v9613(VarCurr)
        | v9614(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_698,axiom,
    ! [VarCurr] :
      ( v9614(VarCurr)
    <=> ( ( v4672(VarCurr,bitIndex2)
        <=> $false )
        & ( v4672(VarCurr,bitIndex1)
        <=> $true )
        & ( v4672(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_697,axiom,
    ! [VarCurr] :
      ( v9613(VarCurr)
    <=> ( ( v4672(VarCurr,bitIndex2)
        <=> $false )
        & ( v4672(VarCurr,bitIndex1)
        <=> $false )
        & ( v4672(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1843,axiom,
    ! [VarCurr] :
      ( v9607(VarCurr)
    <=> ( v9608(VarCurr)
        | v9611(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_696,axiom,
    ! [VarCurr] :
      ( v9611(VarCurr)
    <=> ( ( v4672(VarCurr,bitIndex2)
        <=> $true )
        & ( v4672(VarCurr,bitIndex1)
        <=> $false )
        & ( v4672(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1842,axiom,
    ! [VarCurr] :
      ( v9608(VarCurr)
    <=> ( v9609(VarCurr)
        | v9610(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_695,axiom,
    ! [VarCurr] :
      ( v9610(VarCurr)
    <=> ( ( v4672(VarCurr,bitIndex2)
        <=> $false )
        & ( v4672(VarCurr,bitIndex1)
        <=> $true )
        & ( v4672(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_694,axiom,
    ! [VarCurr] :
      ( v9609(VarCurr)
    <=> ( ( v4672(VarCurr,bitIndex2)
        <=> $true )
        & ( v4672(VarCurr,bitIndex1)
        <=> $false )
        & ( v4672(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_693,axiom,
    ! [VarCurr] :
      ( v9605(VarCurr)
    <=> ( v63(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_692,axiom,
    ! [VarCurr] :
      ( v9604(VarCurr)
    <=> ( v63(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_691,axiom,
    ! [VarCurr] :
      ( v9602(VarCurr)
    <=> ( ( v58(VarCurr,bitIndex2)
        <=> $false )
        & ( v58(VarCurr,bitIndex1)
        <=> $false )
        & ( v58(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeUnaryOperator_839,axiom,
    ! [VarCurr] :
      ( ~ v63(VarCurr)
    <=> v65(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_159,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9586(VarNext)
       => ( v65(VarNext)
        <=> v65(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_175,axiom,
    ! [VarNext] :
      ( v9586(VarNext)
     => ( v65(VarNext)
      <=> v9594(VarNext) ) ) ).

fof(addAssignment_2222,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9594(VarNext)
      <=> v9592(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_251,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ( v9592(VarCurr)
      <=> v9595(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_255,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ( v9592(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_250,axiom,
    ! [VarCurr] :
      ( ~ v67(VarCurr)
     => ( v9595(VarCurr)
      <=> v9596(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_254,axiom,
    ! [VarCurr] :
      ( v67(VarCurr)
     => ( v9595(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1841,axiom,
    ! [VarCurr] :
      ( v9596(VarCurr)
    <=> ( v9597(VarCurr)
        & v65(VarCurr) ) ) ).

fof(writeUnaryOperator_838,axiom,
    ! [VarCurr] :
      ( ~ v9597(VarCurr)
    <=> v9570(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1840,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9586(VarNext)
      <=> v9587(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1839,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9587(VarNext)
      <=> ( v9589(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_837,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9589(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_44,axiom,
    ! [VarCurr] :
      ( ( ~ v8711(VarCurr)
        & ~ v8712(VarCurr)
        & ~ v8743(VarCurr) )
     => ( v9570(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_97,axiom,
    ! [VarCurr] :
      ( v8743(VarCurr)
     => ( v9570(VarCurr)
      <=> v9581(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_246,axiom,
    ! [VarCurr] :
      ( v8712(VarCurr)
     => ( v9570(VarCurr)
      <=> v9572(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_233,axiom,
    ! [VarCurr] :
      ( v8711(VarCurr)
     => ( v9570(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_245,axiom,
    ! [VarCurr] :
      ( ~ v9582(VarCurr)
     => ( v9581(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_232,axiom,
    ! [VarCurr] :
      ( v9582(VarCurr)
     => ( v9581(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_690,axiom,
    ! [VarCurr] :
      ( v9583(VarCurr)
    <=> ( v2961(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_689,axiom,
    ! [VarCurr] :
      ( v9582(VarCurr)
    <=> ( v2961(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_244,axiom,
    ! [VarCurr] :
      ( ~ v8714(VarCurr)
     => ( v9572(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_231,axiom,
    ! [VarCurr] :
      ( v8714(VarCurr)
     => ( v9572(VarCurr)
      <=> v9573(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_43,axiom,
    ! [VarCurr] :
      ( ( ~ v8716(VarCurr)
        & ~ v8718(VarCurr)
        & ~ v8732(VarCurr) )
     => ( v9573(VarCurr)
      <=> v9579(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_96,axiom,
    ! [VarCurr] :
      ( v8732(VarCurr)
     => ( v9573(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_243,axiom,
    ! [VarCurr] :
      ( v8718(VarCurr)
     => ( v9573(VarCurr)
      <=> v9577(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_230,axiom,
    ! [VarCurr] :
      ( v8716(VarCurr)
     => ( v9573(VarCurr)
      <=> v9574(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_242,axiom,
    ! [VarCurr] :
      ( ~ v8737(VarCurr)
     => ( v9579(VarCurr)
      <=> v9580(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_229,axiom,
    ! [VarCurr] :
      ( v8737(VarCurr)
     => ( v9579(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_241,axiom,
    ! [VarCurr] :
      ( ~ v8740(VarCurr)
     => ( v9580(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_228,axiom,
    ! [VarCurr] :
      ( v8740(VarCurr)
     => ( v9580(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_240,axiom,
    ! [VarCurr] :
      ( ~ v9578(VarCurr)
     => ( v9577(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_227,axiom,
    ! [VarCurr] :
      ( v9578(VarCurr)
     => ( v9577(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1838,axiom,
    ! [VarCurr] :
      ( v9578(VarCurr)
    <=> ( v8722(VarCurr)
        | v8727(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_239,axiom,
    ! [VarCurr] :
      ( ~ v9575(VarCurr)
     => ( v9574(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_226,axiom,
    ! [VarCurr] :
      ( v9575(VarCurr)
     => ( v9574(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_688,axiom,
    ! [VarCurr] :
      ( v9576(VarCurr)
    <=> ( v8673(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_687,axiom,
    ! [VarCurr] :
      ( v9575(VarCurr)
    <=> ( v8673(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_95,axiom,
    ! [VarCurr] :
      ( ( ~ v142(VarCurr)
        & ~ v143(VarCurr) )
     => ( v67(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_238,axiom,
    ! [VarCurr] :
      ( v143(VarCurr)
     => ( v67(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_225,axiom,
    ! [VarCurr] :
      ( v142(VarCurr)
     => ( v67(VarCurr)
      <=> v9567(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_237,axiom,
    ! [VarCurr] :
      ( ~ v4649(VarCurr)
     => ( v9567(VarCurr)
      <=> v9568(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_224,axiom,
    ! [VarCurr] :
      ( v4649(VarCurr)
     => ( v9567(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_236,axiom,
    ! [VarCurr] :
      ( ~ v4652(VarCurr)
     => ( v9568(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_223,axiom,
    ! [VarCurr] :
      ( v4652(VarCurr)
     => ( v9568(VarCurr)
      <=> $false ) ) ).

fof(addCaseBooleanConditionEqualRanges1_158,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9554(VarNext)
       => ! [B] :
            ( range_1_0(B)
           => ( v69(VarNext,B)
            <=> v69(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_174,axiom,
    ! [VarNext] :
      ( v9554(VarNext)
     => ! [B] :
          ( range_1_0(B)
         => ( v69(VarNext,B)
          <=> v9562(VarNext,B) ) ) ) ).

fof(addAssignment_2221,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_1_0(B)
         => ( v9562(VarNext,B)
          <=> v9560(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_249,axiom,
    ! [VarCurr] :
      ( ~ v9563(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v9560(VarCurr,B)
          <=> v72(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_253,axiom,
    ! [VarCurr] :
      ( v9563(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v9560(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_686,axiom,
    ! [VarCurr] :
      ( v9563(VarCurr)
    <=> ( v51(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1837,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9554(VarNext)
      <=> v9555(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1836,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9555(VarNext)
      <=> ( v9556(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_836,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9556(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_94,axiom,
    ! [VarCurr] :
      ( ( ~ v9542(VarCurr)
        & ~ v9551(VarCurr) )
     => ! [B] :
          ( range_1_0(B)
         => ( v72(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_235,axiom,
    ! [VarCurr] :
      ( v9551(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v72(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_222,axiom,
    ! [VarCurr] :
      ( v9542(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v72(VarCurr,B)
          <=> v9543(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_685,axiom,
    ! [VarCurr] :
      ( v9551(VarCurr)
    <=> ( ( v69(VarCurr,bitIndex1)
        <=> $false )
        & ( v69(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_234,axiom,
    ! [VarCurr] :
      ( ~ v9544(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v9543(VarCurr,B)
          <=> v9546(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_221,axiom,
    ! [VarCurr] :
      ( v9544(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v9543(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_233,axiom,
    ! [VarCurr] :
      ( ~ v9547(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v9546(VarCurr,B)
          <=> b01(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_220,axiom,
    ! [VarCurr] :
      ( v9547(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v9546(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_684,axiom,
    ! [VarCurr] :
      ( v9549(VarCurr)
    <=> ( v9550(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1835,axiom,
    ! [VarCurr] :
      ( v9550(VarCurr)
    <=> ( v65(VarCurr)
        | v2961(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_683,axiom,
    ! [VarCurr] :
      ( v9547(VarCurr)
    <=> ( v9548(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1834,axiom,
    ! [VarCurr] :
      ( v9548(VarCurr)
    <=> ( v65(VarCurr)
        | v2961(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_682,axiom,
    ! [VarCurr] :
      ( v9545(VarCurr)
    <=> ( v74(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_681,axiom,
    ! [VarCurr] :
      ( v9544(VarCurr)
    <=> ( v74(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_680,axiom,
    ! [VarCurr] :
      ( v9542(VarCurr)
    <=> ( ( v69(VarCurr,bitIndex1)
        <=> $false )
        & ( v69(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2220,axiom,
    ! [VarCurr] :
      ( v2961(VarCurr)
    <=> v2963(VarCurr) ) ).

fof(addAssignment_2219,axiom,
    ! [VarCurr] :
      ( v2963(VarCurr)
    <=> v2965(VarCurr) ) ).

fof(addAssignment_2218,axiom,
    ! [VarCurr] :
      ( v2965(VarCurr)
    <=> v2967(VarCurr) ) ).

fof(addAssignment_2217,axiom,
    ! [VarCurr] :
      ( v2967(VarCurr)
    <=> v2969(VarCurr) ) ).

fof(addAssignment_2216,axiom,
    ! [VarCurr] :
      ( v2969(VarCurr)
    <=> v2971(VarCurr) ) ).

fof(addAssignment_2215,axiom,
    ! [VarCurr] :
      ( v2971(VarCurr)
    <=> v2973(VarCurr) ) ).

fof(addAssignment_2214,axiom,
    ! [VarCurr] :
      ( v2973(VarCurr)
    <=> v2975(VarCurr,bitIndex6) ) ).

fof(addAssignment_2213,axiom,
    ! [VarNext] :
      ( v2975(VarNext,bitIndex6)
    <=> v9534(VarNext,bitIndex6) ) ).

fof(addCaseBooleanConditionEqualRanges1_157,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9535(VarNext)
       => ! [B] :
            ( range_7_0(B)
           => ( v9534(VarNext,B)
            <=> v2975(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_173,axiom,
    ! [VarNext] :
      ( v9535(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v9534(VarNext,B)
          <=> v9482(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1833,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9535(VarNext)
      <=> v9536(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1832,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9536(VarNext)
      <=> ( v9538(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_835,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9538(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2212,axiom,
    ! [VarCurr] :
      ( v2978(VarCurr,bitIndex6)
    <=> v9458(VarCurr,bitIndex6) ) ).

fof(addAssignment_2211,axiom,
    ! [VarCurr] :
      ( v9453(VarCurr,bitIndex6)
    <=> v9454(VarCurr,bitIndex6) ) ).

fof(addAssignment_2210,axiom,
    ! [VarNext] :
      ( v2975(VarNext,bitIndex5)
    <=> v9526(VarNext,bitIndex5) ) ).

fof(addCaseBooleanConditionEqualRanges1_156,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9527(VarNext)
       => ! [B] :
            ( range_7_0(B)
           => ( v9526(VarNext,B)
            <=> v2975(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_172,axiom,
    ! [VarNext] :
      ( v9527(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v9526(VarNext,B)
          <=> v9482(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1831,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9527(VarNext)
      <=> v9528(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1830,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9528(VarNext)
      <=> ( v9530(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_834,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9530(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2209,axiom,
    ! [VarCurr] :
      ( v2978(VarCurr,bitIndex5)
    <=> v9458(VarCurr,bitIndex5) ) ).

fof(addAssignment_2208,axiom,
    ! [VarCurr] :
      ( v9453(VarCurr,bitIndex5)
    <=> v9454(VarCurr,bitIndex5) ) ).

fof(addAssignment_2207,axiom,
    ! [VarNext] :
      ( v2975(VarNext,bitIndex4)
    <=> v9518(VarNext,bitIndex4) ) ).

fof(addCaseBooleanConditionEqualRanges1_155,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9519(VarNext)
       => ! [B] :
            ( range_7_0(B)
           => ( v9518(VarNext,B)
            <=> v2975(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_171,axiom,
    ! [VarNext] :
      ( v9519(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v9518(VarNext,B)
          <=> v9482(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1829,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9519(VarNext)
      <=> v9520(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1828,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9520(VarNext)
      <=> ( v9522(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_833,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9522(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2206,axiom,
    ! [VarCurr] :
      ( v2978(VarCurr,bitIndex4)
    <=> v9458(VarCurr,bitIndex4) ) ).

fof(addAssignment_2205,axiom,
    ! [VarCurr] :
      ( v9453(VarCurr,bitIndex4)
    <=> v9454(VarCurr,bitIndex4) ) ).

fof(addAssignment_2204,axiom,
    ! [VarNext] :
      ( v2975(VarNext,bitIndex3)
    <=> v9510(VarNext,bitIndex3) ) ).

fof(addCaseBooleanConditionEqualRanges1_154,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9511(VarNext)
       => ! [B] :
            ( range_7_0(B)
           => ( v9510(VarNext,B)
            <=> v2975(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_170,axiom,
    ! [VarNext] :
      ( v9511(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v9510(VarNext,B)
          <=> v9482(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1827,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9511(VarNext)
      <=> v9512(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1826,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9512(VarNext)
      <=> ( v9514(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_832,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9514(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2203,axiom,
    ! [VarCurr] :
      ( v2978(VarCurr,bitIndex3)
    <=> v9458(VarCurr,bitIndex3) ) ).

fof(addAssignment_2202,axiom,
    ! [VarCurr] :
      ( v9453(VarCurr,bitIndex3)
    <=> v9454(VarCurr,bitIndex3) ) ).

fof(addAssignment_2201,axiom,
    ! [VarNext] :
      ( v2975(VarNext,bitIndex2)
    <=> v9502(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_153,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9503(VarNext)
       => ! [B] :
            ( range_7_0(B)
           => ( v9502(VarNext,B)
            <=> v2975(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_169,axiom,
    ! [VarNext] :
      ( v9503(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v9502(VarNext,B)
          <=> v9482(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1825,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9503(VarNext)
      <=> v9504(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1824,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9504(VarNext)
      <=> ( v9506(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_831,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9506(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2200,axiom,
    ! [VarCurr] :
      ( v2978(VarCurr,bitIndex2)
    <=> v9458(VarCurr,bitIndex2) ) ).

fof(addAssignment_2199,axiom,
    ! [VarCurr] :
      ( v9453(VarCurr,bitIndex2)
    <=> v9454(VarCurr,bitIndex2) ) ).

fof(addAssignment_2198,axiom,
    ! [VarNext] :
      ( v2975(VarNext,bitIndex1)
    <=> v9494(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_152,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9495(VarNext)
       => ! [B] :
            ( range_7_0(B)
           => ( v9494(VarNext,B)
            <=> v2975(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_168,axiom,
    ! [VarNext] :
      ( v9495(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v9494(VarNext,B)
          <=> v9482(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1823,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9495(VarNext)
      <=> v9496(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1822,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9496(VarNext)
      <=> ( v9498(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_830,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9498(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2197,axiom,
    ! [VarCurr] :
      ( v2978(VarCurr,bitIndex1)
    <=> v9458(VarCurr,bitIndex1) ) ).

fof(addAssignment_2196,axiom,
    ! [VarCurr] :
      ( v9453(VarCurr,bitIndex1)
    <=> v9454(VarCurr,bitIndex1) ) ).

fof(addAssignment_2195,axiom,
    ! [VarNext] :
      ( v2975(VarNext,bitIndex0)
    <=> v9486(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_151,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9487(VarNext)
       => ! [B] :
            ( range_7_0(B)
           => ( v9486(VarNext,B)
            <=> v2975(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_167,axiom,
    ! [VarNext] :
      ( v9487(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v9486(VarNext,B)
          <=> v9482(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1821,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9487(VarNext)
      <=> v9488(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1820,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9488(VarNext)
      <=> ( v9490(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_829,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9490(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2194,axiom,
    ! [VarCurr] :
      ( v2978(VarCurr,bitIndex0)
    <=> v9458(VarCurr,bitIndex0) ) ).

fof(addAssignment_2193,axiom,
    ! [VarNext] :
      ( v2975(VarNext,bitIndex7)
    <=> v9473(VarNext,bitIndex7) ) ).

fof(addCaseBooleanConditionEqualRanges1_150,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9474(VarNext)
       => ! [B] :
            ( range_7_0(B)
           => ( v9473(VarNext,B)
            <=> v2975(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_166,axiom,
    ! [VarNext] :
      ( v9474(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v9473(VarNext,B)
          <=> v9482(VarNext,B) ) ) ) ).

fof(addAssignment_2192,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v9482(VarNext,B)
          <=> v9480(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_248,axiom,
    ! [VarCurr] :
      ( ~ v3102(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v9480(VarCurr,B)
          <=> v2978(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_252,axiom,
    ! [VarCurr] :
      ( v3102(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v9480(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1819,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9474(VarNext)
      <=> v9475(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1818,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9475(VarNext)
      <=> ( v9477(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_828,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9477(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2191,axiom,
    ! [VarCurr] :
      ( v2978(VarCurr,bitIndex7)
    <=> v9458(VarCurr,bitIndex7) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_247,axiom,
    ! [VarCurr] :
      ( ~ v9459(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v9458(VarCurr,B)
          <=> v9460(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_251,axiom,
    ! [VarCurr] :
      ( v9459(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v9458(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_42,axiom,
    ! [VarCurr] :
      ( ( ~ v9461(VarCurr)
        & ~ v9463(VarCurr)
        & ~ v9467(VarCurr) )
     => ! [B] :
          ( range_7_0(B)
         => ( v9460(VarCurr,B)
          <=> v2975(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_93,axiom,
    ! [VarCurr] :
      ( v9467(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v9460(VarCurr,B)
          <=> v9469(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_232,axiom,
    ! [VarCurr] :
      ( v9463(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v9460(VarCurr,B)
          <=> v9465(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_219,axiom,
    ! [VarCurr] :
      ( v9461(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v9460(VarCurr,B)
          <=> v2975(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_679,axiom,
    ! [VarCurr] :
      ( v9470(VarCurr)
    <=> ( ( v9471(VarCurr,bitIndex1)
        <=> $true )
        & ( v9471(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2190,axiom,
    ! [VarCurr] :
      ( v9471(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2189,axiom,
    ! [VarCurr] :
      ( v9471(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(addAssignment_2188,axiom,
    ! [VarCurr] :
      ( v9469(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_2187,axiom,
    ! [VarCurr,B] :
      ( range_7_1(B)
     => ( v9469(VarCurr,B)
      <=> v9453(VarCurr,B) ) ) ).

fof(range_axiom_52,axiom,
    ! [B] :
      ( range_7_1(B)
    <=> ( $false
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B ) ) ).

fof(addBitVectorEqualityBitBlasted_678,axiom,
    ! [VarCurr] :
      ( v9467(VarCurr)
    <=> ( ( v9468(VarCurr,bitIndex1)
        <=> $true )
        & ( v9468(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2186,axiom,
    ! [VarCurr] :
      ( v9468(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2185,axiom,
    ! [VarCurr] :
      ( v9468(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(addAssignment_2184,axiom,
    ! [VarCurr] :
      ( ( v9465(VarCurr,bitIndex6)
      <=> v2975(VarCurr,bitIndex7) )
      & ( v9465(VarCurr,bitIndex5)
      <=> v2975(VarCurr,bitIndex6) )
      & ( v9465(VarCurr,bitIndex4)
      <=> v2975(VarCurr,bitIndex5) )
      & ( v9465(VarCurr,bitIndex3)
      <=> v2975(VarCurr,bitIndex4) )
      & ( v9465(VarCurr,bitIndex2)
      <=> v2975(VarCurr,bitIndex3) )
      & ( v9465(VarCurr,bitIndex1)
      <=> v2975(VarCurr,bitIndex2) )
      & ( v9465(VarCurr,bitIndex0)
      <=> v2975(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_2183,axiom,
    ! [VarCurr] :
      ( v9465(VarCurr,bitIndex7)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_677,axiom,
    ! [VarCurr] :
      ( v9463(VarCurr)
    <=> ( ( v9464(VarCurr,bitIndex1)
        <=> $false )
        & ( v9464(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2182,axiom,
    ! [VarCurr] :
      ( v9464(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2181,axiom,
    ! [VarCurr] :
      ( v9464(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_676,axiom,
    ! [VarCurr] :
      ( v9461(VarCurr)
    <=> ( ( v9462(VarCurr,bitIndex1)
        <=> $false )
        & ( v9462(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2180,axiom,
    ! [VarCurr] :
      ( v9462(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2179,axiom,
    ! [VarCurr] :
      ( v9462(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeUnaryOperator_827,axiom,
    ! [VarCurr] :
      ( ~ v9459(VarCurr)
    <=> v33(VarCurr) ) ).

fof(addAssignment_2178,axiom,
    ! [VarCurr] :
      ( v9453(VarCurr,bitIndex7)
    <=> v9454(VarCurr,bitIndex7) ) ).

fof(addAssignment_2177,axiom,
    ! [VarCurr] :
      ( v9454(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_2176,axiom,
    ! [VarCurr] :
      ( ( v9454(VarCurr,bitIndex7)
      <=> v2975(VarCurr,bitIndex6) )
      & ( v9454(VarCurr,bitIndex6)
      <=> v2975(VarCurr,bitIndex5) )
      & ( v9454(VarCurr,bitIndex5)
      <=> v2975(VarCurr,bitIndex4) )
      & ( v9454(VarCurr,bitIndex4)
      <=> v2975(VarCurr,bitIndex3) )
      & ( v9454(VarCurr,bitIndex3)
      <=> v2975(VarCurr,bitIndex2) )
      & ( v9454(VarCurr,bitIndex2)
      <=> v2975(VarCurr,bitIndex1) )
      & ( v9454(VarCurr,bitIndex1)
      <=> v2975(VarCurr,bitIndex0) ) ) ).

fof(addAssignmentInitValue_151,axiom,
    ~ v2975(constB0,bitIndex7) ).

fof(addAssignmentInitValue_150,axiom,
    ~ v2975(constB0,bitIndex6) ).

fof(addAssignmentInitValue_149,axiom,
    ~ v2975(constB0,bitIndex5) ).

fof(addAssignmentInitValue_148,axiom,
    ~ v2975(constB0,bitIndex3) ).

fof(addAssignmentInitValue_147,axiom,
    ~ v2975(constB0,bitIndex2) ).

fof(addAssignmentInitValue_146,axiom,
    ~ v2975(constB0,bitIndex1) ).

fof(addAssignmentInitValue_145,axiom,
    ~ v2975(constB0,bitIndex0) ).

fof(bitBlastConstant_914,axiom,
    ~ b000x0000(bitIndex7) ).

fof(bitBlastConstant_913,axiom,
    ~ b000x0000(bitIndex6) ).

fof(bitBlastConstant_912,axiom,
    ~ b000x0000(bitIndex5) ).

fof(bitBlastConstant_911,axiom,
    ~ b000x0000(bitIndex3) ).

fof(bitBlastConstant_910,axiom,
    ~ b000x0000(bitIndex2) ).

fof(bitBlastConstant_909,axiom,
    ~ b000x0000(bitIndex1) ).

fof(bitBlastConstant_908,axiom,
    ~ b000x0000(bitIndex0) ).

fof(addAssignment_2175,axiom,
    ! [VarCurr] :
      ( v2980(VarCurr)
    <=> v2982(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1817,axiom,
    ! [VarCurr] :
      ( v2982(VarCurr)
    <=> ( v9451(VarCurr)
        | v9446(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1816,axiom,
    ! [VarCurr] :
      ( v9451(VarCurr)
    <=> ( v2984(VarCurr)
        | v3012(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_246,axiom,
    ! [VarCurr] :
      ( ~ v9448(VarCurr)
     => ( v9446(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_250,axiom,
    ! [VarCurr] :
      ( v9448(VarCurr)
     => ( v9446(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1815,axiom,
    ! [VarCurr] :
      ( v9448(VarCurr)
    <=> ( v9449(VarCurr)
        & v9306(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1814,axiom,
    ! [VarCurr] :
      ( v9449(VarCurr)
    <=> ( v9422(VarCurr)
        & v9305(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_245,axiom,
    ! [VarCurr] :
      ( ~ v9443(VarCurr)
     => ( v2984(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_249,axiom,
    ! [VarCurr] :
      ( v9443(VarCurr)
     => ( v2984(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1813,axiom,
    ! [VarCurr] :
      ( v9443(VarCurr)
    <=> ( v9444(VarCurr)
        & v9306(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1812,axiom,
    ! [VarCurr] :
      ( v9444(VarCurr)
    <=> ( v9336(VarCurr)
        & v9305(VarCurr) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_149,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9431(VarNext)
       => ( v2986(VarNext,bitIndex0)
        <=> v2986(VarCurr,bitIndex0) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_165,axiom,
    ! [VarNext] :
      ( v9431(VarNext)
     => ( v2986(VarNext,bitIndex0)
      <=> v9439(VarNext) ) ) ).

fof(addAssignment_2174,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9439(VarNext)
      <=> v9437(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_244,axiom,
    ! [VarCurr] :
      ( ~ v9327(VarCurr)
     => ( v9437(VarCurr)
      <=> v2988(VarCurr,bitIndex0) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_248,axiom,
    ! [VarCurr] :
      ( v9327(VarCurr)
     => ( v9437(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1811,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9431(VarNext)
      <=> v9432(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1810,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9432(VarNext)
      <=> ( v9434(VarNext)
          & v3082(VarNext) ) ) ) ).

fof(writeUnaryOperator_826,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9434(VarNext)
      <=> v9320(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_243,axiom,
    ! [VarCurr] :
      ( ~ v9413(VarCurr)
     => ( v2988(VarCurr,bitIndex0)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_247,axiom,
    ! [VarCurr] :
      ( v9413(VarCurr)
     => ( v2988(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1809,axiom,
    ! [VarCurr] :
      ( v9413(VarCurr)
    <=> ( v9414(VarCurr)
        | v9427(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1808,axiom,
    ! [VarCurr] :
      ( v9427(VarCurr)
    <=> ( v9428(VarCurr)
        & v9341(VarCurr) ) ) ).

fof(writeUnaryOperator_825,axiom,
    ! [VarCurr] :
      ( ~ v9428(VarCurr)
    <=> v2990(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1807,axiom,
    ! [VarCurr] :
      ( v9414(VarCurr)
    <=> ( v9415(VarCurr)
        | v9426(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1806,axiom,
    ! [VarCurr] :
      ( v9426(VarCurr)
    <=> ( v9358(VarCurr)
        & v9313(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1805,axiom,
    ! [VarCurr] :
      ( v9415(VarCurr)
    <=> ( v9416(VarCurr)
        & v9306(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1804,axiom,
    ! [VarCurr] :
      ( v9416(VarCurr)
    <=> ( v9417(VarCurr)
        | v9425(VarCurr) ) ) ).

fof(writeUnaryOperator_824,axiom,
    ! [VarCurr] :
      ( ~ v9425(VarCurr)
    <=> v9305(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1803,axiom,
    ! [VarCurr] :
      ( v9417(VarCurr)
    <=> ( v9418(VarCurr)
        & v9305(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1802,axiom,
    ! [VarCurr] :
      ( v9418(VarCurr)
    <=> ( v9419(VarCurr)
        | v9423(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1801,axiom,
    ! [VarCurr] :
      ( v9423(VarCurr)
    <=> ( v9424(VarCurr)
        & v9304(VarCurr) ) ) ).

fof(writeUnaryOperator_823,axiom,
    ! [VarCurr] :
      ( ~ v9424(VarCurr)
    <=> v3006(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1800,axiom,
    ! [VarCurr] :
      ( v9419(VarCurr)
    <=> ( v9420(VarCurr)
        | v9422(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_675,axiom,
    ! [VarCurr] :
      ( v9422(VarCurr)
    <=> ( ( v27(VarCurr,bitIndex1)
        <=> $false )
        & ( v27(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1799,axiom,
    ! [VarCurr] :
      ( v9420(VarCurr)
    <=> ( v9421(VarCurr)
        & v9336(VarCurr) ) ) ).

fof(writeUnaryOperator_822,axiom,
    ! [VarCurr] :
      ( ~ v9421(VarCurr)
    <=> v2990(VarCurr) ) ).

fof(writeUnaryOperator_821,axiom,
    ! [VarCurr] :
      ( ~ v2990(VarCurr)
    <=> v9411(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_374,axiom,
    ! [VarCurr] :
      ( v9411(VarCurr)
    <=> ( v9389(VarCurr)
        | v2992(VarCurr,bitIndex2) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_148,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9397(VarNext)
       => ! [B] :
            ( range_2_0(B)
           => ( v2992(VarNext,B)
            <=> v2992(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_164,axiom,
    ! [VarNext] :
      ( v9397(VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v2992(VarNext,B)
          <=> v9405(VarNext,B) ) ) ) ).

fof(addAssignment_2173,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v9405(VarNext,B)
          <=> v9403(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_242,axiom,
    ! [VarCurr] :
      ( ~ v9406(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9403(VarCurr,B)
          <=> v2994(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_246,axiom,
    ! [VarCurr] :
      ( v9406(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v9403(VarCurr,B)
          <=> b100(B) ) ) ) ).

fof(writeUnaryOperator_820,axiom,
    ! [VarCurr] :
      ( ~ v9406(VarCurr)
    <=> v35(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1798,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9397(VarNext)
      <=> v9398(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1797,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9398(VarNext)
      <=> ( v9399(VarNext)
          & v3082(VarNext) ) ) ) ).

fof(writeUnaryOperator_819,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9399(VarNext)
      <=> v9320(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_92,axiom,
    ! [VarCurr] :
      ( ( ~ v9362(VarCurr)
        & ~ v9378(VarCurr) )
     => ! [B] :
          ( range_2_0(B)
         => ( v2994(VarCurr,B)
          <=> v2992(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_231,axiom,
    ! [VarCurr] :
      ( v9378(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v2994(VarCurr,B)
          <=> v9380(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_218,axiom,
    ! [VarCurr] :
      ( v9362(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v2994(VarCurr,B)
          <=> v9364(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1796,axiom,
    ! [VarCurr] :
      ( v9390(VarCurr)
    <=> ( v9391(VarCurr)
        | v9393(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_674,axiom,
    ! [VarCurr] :
      ( v9393(VarCurr)
    <=> ( ( v9394(VarCurr,bitIndex1)
        <=> $true )
        & ( v9394(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2172,axiom,
    ! [VarCurr] :
      ( v9394(VarCurr,bitIndex0)
    <=> v3004(VarCurr) ) ).

fof(addAssignment_2171,axiom,
    ! [VarCurr] :
      ( v9394(VarCurr,bitIndex1)
    <=> v2996(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_673,axiom,
    ! [VarCurr] :
      ( v9391(VarCurr)
    <=> ( ( v9392(VarCurr,bitIndex1)
        <=> $false )
        & ( v9392(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2170,axiom,
    ! [VarCurr] :
      ( v9392(VarCurr,bitIndex0)
    <=> v3004(VarCurr) ) ).

fof(addAssignment_2169,axiom,
    ! [VarCurr] :
      ( v9392(VarCurr,bitIndex1)
    <=> v2996(VarCurr) ) ).

fof(addAssignment_2168,axiom,
    ! [VarCurr] :
      ( v9380(VarCurr,bitIndex0)
    <=> v9376(VarCurr) ) ).

fof(addAssignment_2167,axiom,
    ! [VarCurr] :
      ( v9380(VarCurr,bitIndex1)
    <=> v9387(VarCurr) ) ).

fof(addAssignment_2166,axiom,
    ! [VarCurr] :
      ( v9380(VarCurr,bitIndex2)
    <=> v9382(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1795,axiom,
    ! [VarCurr] :
      ( v9387(VarCurr)
    <=> ( v9388(VarCurr)
        & v9389(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_373,axiom,
    ! [VarCurr] :
      ( v9389(VarCurr)
    <=> ( v2992(VarCurr,bitIndex0)
        | v2992(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1794,axiom,
    ! [VarCurr] :
      ( v9388(VarCurr)
    <=> ( v9376(VarCurr)
        | v9371(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1793,axiom,
    ! [VarCurr] :
      ( v9382(VarCurr)
    <=> ( v9383(VarCurr)
        & v9386(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_372,axiom,
    ! [VarCurr] :
      ( v9386(VarCurr)
    <=> ( v2992(VarCurr,bitIndex2)
        | v9385(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1792,axiom,
    ! [VarCurr] :
      ( v9383(VarCurr)
    <=> ( v9373(VarCurr)
        | v9384(VarCurr) ) ) ).

fof(writeUnaryOperator_818,axiom,
    ! [VarCurr] :
      ( ~ v9384(VarCurr)
    <=> v9385(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_371,axiom,
    ! [VarCurr] :
      ( v9385(VarCurr)
    <=> ( v2992(VarCurr,bitIndex0)
        & v2992(VarCurr,bitIndex1) ) ) ).

fof(addBitVectorEqualityBitBlasted_672,axiom,
    ! [VarCurr] :
      ( v9378(VarCurr)
    <=> ( ( v9379(VarCurr,bitIndex1)
        <=> $true )
        & ( v9379(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2165,axiom,
    ! [VarCurr] :
      ( v9379(VarCurr,bitIndex0)
    <=> v3004(VarCurr) ) ).

fof(addAssignment_2164,axiom,
    ! [VarCurr] :
      ( v9379(VarCurr,bitIndex1)
    <=> v2996(VarCurr) ) ).

fof(addAssignment_2163,axiom,
    ! [VarCurr] :
      ( v9364(VarCurr,bitIndex0)
    <=> v9376(VarCurr) ) ).

fof(addAssignment_2162,axiom,
    ! [VarCurr] :
      ( v9364(VarCurr,bitIndex1)
    <=> v9374(VarCurr) ) ).

fof(addAssignment_2161,axiom,
    ! [VarCurr] :
      ( v9364(VarCurr,bitIndex2)
    <=> v9366(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1791,axiom,
    ! [VarCurr] :
      ( v9374(VarCurr)
    <=> ( v9375(VarCurr)
        & v9377(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1790,axiom,
    ! [VarCurr] :
      ( v9377(VarCurr)
    <=> ( v2992(VarCurr,bitIndex0)
        | v9371(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_370,axiom,
    ! [VarCurr] :
      ( v9375(VarCurr)
    <=> ( v9376(VarCurr)
        | v2992(VarCurr,bitIndex1) ) ) ).

fof(writeUnaryOperator_817,axiom,
    ! [VarCurr] :
      ( ~ v9376(VarCurr)
    <=> v2992(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1789,axiom,
    ! [VarCurr] :
      ( v9366(VarCurr)
    <=> ( v9367(VarCurr)
        & v9372(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1788,axiom,
    ! [VarCurr] :
      ( v9372(VarCurr)
    <=> ( v9369(VarCurr)
        | v9373(VarCurr) ) ) ).

fof(writeUnaryOperator_816,axiom,
    ! [VarCurr] :
      ( ~ v9373(VarCurr)
    <=> v2992(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges_369,axiom,
    ! [VarCurr] :
      ( v9367(VarCurr)
    <=> ( v9368(VarCurr)
        | v2992(VarCurr,bitIndex2) ) ) ).

fof(writeUnaryOperator_815,axiom,
    ! [VarCurr] :
      ( ~ v9368(VarCurr)
    <=> v9369(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_368,axiom,
    ! [VarCurr] :
      ( v9369(VarCurr)
    <=> ( v2992(VarCurr,bitIndex1)
        | v9370(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1787,axiom,
    ! [VarCurr] :
      ( v9370(VarCurr)
    <=> ( v2992(VarCurr,bitIndex0)
        & v9371(VarCurr) ) ) ).

fof(writeUnaryOperator_814,axiom,
    ! [VarCurr] :
      ( ~ v9371(VarCurr)
    <=> v2992(VarCurr,bitIndex1) ) ).

fof(addAssignmentInitValue_144,axiom,
    v2992(constB0,bitIndex2) ).

fof(addAssignmentInitValue_143,axiom,
    ~ v2992(constB0,bitIndex1) ).

fof(addAssignmentInitValue_142,axiom,
    ~ v2992(constB0,bitIndex0) ).

fof(addBitVectorEqualityBitBlasted_671,axiom,
    ! [VarCurr] :
      ( v9362(VarCurr)
    <=> ( ( v9363(VarCurr,bitIndex1)
        <=> $false )
        & ( v9363(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2160,axiom,
    ! [VarCurr] :
      ( v9363(VarCurr,bitIndex0)
    <=> v3004(VarCurr) ) ).

fof(addAssignment_2159,axiom,
    ! [VarCurr] :
      ( v9363(VarCurr,bitIndex1)
    <=> v2996(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_241,axiom,
    ! [VarCurr] :
      ( ~ v9351(VarCurr)
     => ( v3004(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_245,axiom,
    ! [VarCurr] :
      ( v9351(VarCurr)
     => ( v3004(VarCurr)
      <=> v9355(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_91,axiom,
    ! [VarCurr] :
      ( ( ~ v9353(VarCurr)
        & ~ v9313(VarCurr) )
     => ( v9355(VarCurr)
      <=> v9360(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_230,axiom,
    ! [VarCurr] :
      ( v9313(VarCurr)
     => ( v9355(VarCurr)
      <=> v9357(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_217,axiom,
    ! [VarCurr] :
      ( v9353(VarCurr)
     => ( v9355(VarCurr)
      <=> v9356(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_240,axiom,
    ! [VarCurr] :
      ( ~ v2990(VarCurr)
     => ( v9360(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_244,axiom,
    ! [VarCurr] :
      ( v2990(VarCurr)
     => ( v9360(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_90,axiom,
    ! [VarCurr] :
      ( ( ~ v9308(VarCurr)
        & ~ v9358(VarCurr) )
     => ( v9357(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_229,axiom,
    ! [VarCurr] :
      ( v9358(VarCurr)
     => ( v9357(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_216,axiom,
    ! [VarCurr] :
      ( v9308(VarCurr)
     => ( v9357(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_670,axiom,
    ! [VarCurr] :
      ( v9358(VarCurr)
    <=> ( ( v9359(VarCurr,bitIndex1)
        <=> $true )
        & ( v9359(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2158,axiom,
    ! [VarCurr] :
      ( v9359(VarCurr,bitIndex0)
    <=> v2990(VarCurr) ) ).

fof(addAssignment_2157,axiom,
    ! [VarCurr] :
      ( v9359(VarCurr,bitIndex1)
    <=> v3012(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_239,axiom,
    ! [VarCurr] :
      ( ~ v2990(VarCurr)
     => ( v9356(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_243,axiom,
    ! [VarCurr] :
      ( v2990(VarCurr)
     => ( v9356(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1786,axiom,
    ! [VarCurr] :
      ( v9351(VarCurr)
    <=> ( v9352(VarCurr)
        | v9341(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1785,axiom,
    ! [VarCurr] :
      ( v9352(VarCurr)
    <=> ( v9353(VarCurr)
        | v9313(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1784,axiom,
    ! [VarCurr] :
      ( v9353(VarCurr)
    <=> ( v9354(VarCurr)
        & v9306(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1783,axiom,
    ! [VarCurr] :
      ( v9354(VarCurr)
    <=> ( v9336(VarCurr)
        & v9305(VarCurr) ) ) ).

fof(addAssignment_2156,axiom,
    ! [VarNext] :
      ( v2986(VarNext,bitIndex1)
    <=> v9343(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionShiftedRanges1_24,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9344(VarNext)
       => ( ( v9343(VarNext,bitIndex1)
          <=> v2986(VarCurr,bitIndex2) )
          & ( v9343(VarNext,bitIndex0)
          <=> v2986(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_163,axiom,
    ! [VarNext] :
      ( v9344(VarNext)
     => ! [B] :
          ( range_1_0(B)
         => ( v9343(VarNext,B)
          <=> v9326(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1782,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9344(VarNext)
      <=> v9345(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1781,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9345(VarNext)
      <=> ( v9347(VarNext)
          & v3082(VarNext) ) ) ) ).

fof(writeUnaryOperator_813,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9347(VarNext)
      <=> v9320(VarNext) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_111,axiom,
    ! [VarCurr] :
      ( ~ v9331(VarCurr)
     => ( v2988(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_107,axiom,
    ! [VarCurr] :
      ( v9331(VarCurr)
     => ( v2988(VarCurr,bitIndex1)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1780,axiom,
    ! [VarCurr] :
      ( v9331(VarCurr)
    <=> ( v9332(VarCurr)
        | v9340(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1779,axiom,
    ! [VarCurr] :
      ( v9340(VarCurr)
    <=> ( v2990(VarCurr)
        & v9341(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_669,axiom,
    ! [VarCurr] :
      ( v9341(VarCurr)
    <=> ( $true
      <=> v2986(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1778,axiom,
    ! [VarCurr] :
      ( v9332(VarCurr)
    <=> ( v9333(VarCurr)
        | v9337(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1777,axiom,
    ! [VarCurr] :
      ( v9337(VarCurr)
    <=> ( v9338(VarCurr)
        & v9313(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_668,axiom,
    ! [VarCurr] :
      ( v9338(VarCurr)
    <=> ( ( v9339(VarCurr,bitIndex1)
        <=> $true )
        & ( v9339(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2155,axiom,
    ! [VarCurr] :
      ( v9339(VarCurr,bitIndex0)
    <=> v2990(VarCurr) ) ).

fof(addAssignment_2154,axiom,
    ! [VarCurr] :
      ( v9339(VarCurr,bitIndex1)
    <=> v3012(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1776,axiom,
    ! [VarCurr] :
      ( v9333(VarCurr)
    <=> ( v9334(VarCurr)
        & v9306(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1775,axiom,
    ! [VarCurr] :
      ( v9334(VarCurr)
    <=> ( v9335(VarCurr)
        & v9305(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1774,axiom,
    ! [VarCurr] :
      ( v9335(VarCurr)
    <=> ( v2990(VarCurr)
        & v9336(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_667,axiom,
    ! [VarCurr] :
      ( v9336(VarCurr)
    <=> ( ( v27(VarCurr,bitIndex1)
        <=> $false )
        & ( v27(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2153,axiom,
    ! [VarNext] :
      ( v2986(VarNext,bitIndex2)
    <=> v9315(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionShiftedRanges1_23,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9316(VarNext)
       => ( ( v9315(VarNext,bitIndex1)
          <=> v2986(VarCurr,bitIndex2) )
          & ( v9315(VarNext,bitIndex0)
          <=> v2986(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_162,axiom,
    ! [VarNext] :
      ( v9316(VarNext)
     => ! [B] :
          ( range_1_0(B)
         => ( v9315(VarNext,B)
          <=> v9326(VarNext,B) ) ) ) ).

fof(addAssignment_2152,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_1_0(B)
         => ( v9326(VarNext,B)
          <=> v9324(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_110,axiom,
    ! [VarCurr] :
      ( ~ v9327(VarCurr)
     => ( ( v9324(VarCurr,bitIndex1)
        <=> v2988(VarCurr,bitIndex2) )
        & ( v9324(VarCurr,bitIndex0)
        <=> v2988(VarCurr,bitIndex1) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_242,axiom,
    ! [VarCurr] :
      ( v9327(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v9324(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_812,axiom,
    ! [VarCurr] :
      ( ~ v9327(VarCurr)
    <=> v35(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1773,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9316(VarNext)
      <=> v9317(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1772,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9317(VarNext)
      <=> ( v9318(VarNext)
          & v3082(VarNext) ) ) ) ).

fof(writeUnaryOperator_811,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9318(VarNext)
      <=> v9320(VarNext) ) ) ).

fof(addAssignment_2151,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9320(VarNext)
      <=> v3082(VarCurr) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_109,axiom,
    ! [VarCurr] :
      ( ~ v9300(VarCurr)
     => ( v2988(VarCurr,bitIndex2)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_106,axiom,
    ! [VarCurr] :
      ( v9300(VarCurr)
     => ( v2988(VarCurr,bitIndex2)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1771,axiom,
    ! [VarCurr] :
      ( v9300(VarCurr)
    <=> ( v9301(VarCurr)
        | v9307(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1770,axiom,
    ! [VarCurr] :
      ( v9307(VarCurr)
    <=> ( v9308(VarCurr)
        & v9313(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_666,axiom,
    ! [VarCurr] :
      ( v9313(VarCurr)
    <=> ( $true
      <=> v2986(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1769,axiom,
    ! [VarCurr] :
      ( v9308(VarCurr)
    <=> ( v9309(VarCurr)
        | v9311(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_665,axiom,
    ! [VarCurr] :
      ( v9311(VarCurr)
    <=> ( ( v9312(VarCurr,bitIndex1)
        <=> $false )
        & ( v9312(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2150,axiom,
    ! [VarCurr] :
      ( v9312(VarCurr,bitIndex0)
    <=> v2990(VarCurr) ) ).

fof(addAssignment_2149,axiom,
    ! [VarCurr] :
      ( v9312(VarCurr,bitIndex1)
    <=> v3012(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_664,axiom,
    ! [VarCurr] :
      ( v9309(VarCurr)
    <=> ( ( v9310(VarCurr,bitIndex1)
        <=> $false )
        & ( v9310(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2148,axiom,
    ! [VarCurr] :
      ( v9310(VarCurr,bitIndex0)
    <=> v2990(VarCurr) ) ).

fof(addAssignment_2147,axiom,
    ! [VarCurr] :
      ( v9310(VarCurr,bitIndex1)
    <=> v3012(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1768,axiom,
    ! [VarCurr] :
      ( v9301(VarCurr)
    <=> ( v9302(VarCurr)
        & v9306(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_663,axiom,
    ! [VarCurr] :
      ( v9306(VarCurr)
    <=> ( $true
      <=> v2986(VarCurr,bitIndex0) ) ) ).

fof(addAssignmentInitValueVector_44,axiom,
    ( ( v2986(constB0,bitIndex2)
    <=> $false )
    & ( v2986(constB0,bitIndex1)
    <=> $false ) ) ).

fof(addAssignmentInitValueVector_43,axiom,
    ( v2986(constB0,bitIndex0)
  <=> $true ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1767,axiom,
    ! [VarCurr] :
      ( v9302(VarCurr)
    <=> ( v9303(VarCurr)
        & v9305(VarCurr) ) ) ).

fof(writeUnaryOperator_810,axiom,
    ! [VarCurr] :
      ( ~ v9305(VarCurr)
    <=> v29(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1766,axiom,
    ! [VarCurr] :
      ( v9303(VarCurr)
    <=> ( v3006(VarCurr)
        & v9304(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_662,axiom,
    ! [VarCurr] :
      ( v9304(VarCurr)
    <=> ( ( v27(VarCurr,bitIndex1)
        <=> $true )
        & ( v27(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2146,axiom,
    ! [VarCurr] :
      ( v3012(VarCurr)
    <=> v3014(VarCurr) ) ).

fof(addAssignment_2145,axiom,
    ! [VarCurr] :
      ( v3014(VarCurr)
    <=> v3016(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1765,axiom,
    ! [VarCurr] :
      ( v3016(VarCurr)
    <=> ( v9298(VarCurr)
        & v3018(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_367,axiom,
    ! [VarCurr] :
      ( v9298(VarCurr)
    <=> ( v6(VarCurr,bitIndex2)
        | v6(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_2144,axiom,
    ! [VarCurr] :
      ( v3018(VarCurr)
    <=> v3020(VarCurr) ) ).

fof(addAssignment_2143,axiom,
    ! [VarCurr] :
      ( v3020(VarCurr)
    <=> v3022(VarCurr) ) ).

fof(addAssignment_2142,axiom,
    ! [VarCurr] :
      ( v3022(VarCurr)
    <=> v3024(VarCurr) ) ).

fof(addAssignment_2141,axiom,
    ! [VarCurr] :
      ( v3024(VarCurr)
    <=> v3026(VarCurr) ) ).

fof(addAssignment_2140,axiom,
    ! [VarCurr] :
      ( v3026(VarCurr)
    <=> v3028(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_147,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9285(VarNext)
       => ( v3028(VarNext)
        <=> v3028(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_161,axiom,
    ! [VarNext] :
      ( v9285(VarNext)
     => ( v3028(VarNext)
      <=> v9293(VarNext) ) ) ).

fof(addAssignment_2139,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9293(VarNext)
      <=> v9291(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_238,axiom,
    ! [VarCurr] :
      ( ~ v9294(VarCurr)
     => ( v9291(VarCurr)
      <=> v3034(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_241,axiom,
    ! [VarCurr] :
      ( v9294(VarCurr)
     => ( v9291(VarCurr)
      <=> $false ) ) ).

fof(writeUnaryOperator_809,axiom,
    ! [VarCurr] :
      ( ~ v9294(VarCurr)
    <=> v3030(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1764,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9285(VarNext)
      <=> v9286(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1763,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9286(VarNext)
      <=> ( v9287(VarNext)
          & v9185(VarNext) ) ) ) ).

fof(writeUnaryOperator_808,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9287(VarNext)
      <=> v9194(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_237,axiom,
    ! [VarCurr] :
      ( ~ v9244(VarCurr)
     => ( v3034(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_240,axiom,
    ! [VarCurr] :
      ( v9244(VarCurr)
     => ( v3034(VarCurr)
      <=> v9268(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_228,axiom,
    ! [VarCurr] :
      ( ~ v9205(VarCurr)
     => ( v9268(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_215,axiom,
    ! [VarCurr] :
      ( v9205(VarCurr)
     => ( v9268(VarCurr)
      <=> v9269(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1762,axiom,
    ! [VarCurr] :
      ( v9275(VarCurr)
    <=> ( v9277(VarCurr)
        | v9257(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1761,axiom,
    ! [VarCurr] :
      ( v9277(VarCurr)
    <=> ( v9278(VarCurr)
        | v9256(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1760,axiom,
    ! [VarCurr] :
      ( v9278(VarCurr)
    <=> ( v9279(VarCurr)
        | v9255(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1759,axiom,
    ! [VarCurr] :
      ( v9279(VarCurr)
    <=> ( v9280(VarCurr)
        | v9225(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1758,axiom,
    ! [VarCurr] :
      ( v9280(VarCurr)
    <=> ( v9281(VarCurr)
        | v9224(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1757,axiom,
    ! [VarCurr] :
      ( v9281(VarCurr)
    <=> ( v9282(VarCurr)
        | v9223(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1756,axiom,
    ! [VarCurr] :
      ( v9282(VarCurr)
    <=> ( v9208(VarCurr)
        | v9222(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1755,axiom,
    ! [VarCurr] :
      ( v9208(VarCurr)
    <=> ( v9209(VarCurr)
        | v9214(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_236,axiom,
    ! [VarCurr] :
      ( ~ v3040(VarCurr)
     => ( v9269(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_239,axiom,
    ! [VarCurr] :
      ( v3040(VarCurr)
     => ( v9269(VarCurr)
      <=> v9270(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_235,axiom,
    ! [VarCurr] :
      ( ~ v9271(VarCurr)
     => ( v9270(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_238,axiom,
    ! [VarCurr] :
      ( v9271(VarCurr)
     => ( v9270(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1754,axiom,
    ! [VarCurr] :
      ( v9271(VarCurr)
    <=> ( v9272(VarCurr)
        & v9183(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1753,axiom,
    ! [VarCurr] :
      ( v9272(VarCurr)
    <=> ( v9273(VarCurr)
        | v9274(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_661,axiom,
    ! [VarCurr] :
      ( v9274(VarCurr)
    <=> ( ( v9145(VarCurr,bitIndex3)
        <=> $true )
        & ( v9145(VarCurr,bitIndex2)
        <=> $true )
        & ( v9145(VarCurr,bitIndex1)
        <=> $false )
        & ( v9145(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_660,axiom,
    ! [VarCurr] :
      ( v9273(VarCurr)
    <=> ( ( v9145(VarCurr,bitIndex3)
        <=> $false )
        & ( v9145(VarCurr,bitIndex2)
        <=> $true )
        & ( v9145(VarCurr,bitIndex1)
        <=> $false )
        & ( v9145(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1752,axiom,
    ! [VarCurr] :
      ( v9244(VarCurr)
    <=> ( v9245(VarCurr)
        | v9257(VarCurr) ) ) ).

fof(writeUnaryOperator_807,axiom,
    ! [VarCurr] :
      ( ~ v9257(VarCurr)
    <=> v9258(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1751,axiom,
    ! [VarCurr] :
      ( v9258(VarCurr)
    <=> ( v9259(VarCurr)
        | v9226(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1750,axiom,
    ! [VarCurr] :
      ( v9259(VarCurr)
    <=> ( v9260(VarCurr)
        | v9225(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1749,axiom,
    ! [VarCurr] :
      ( v9260(VarCurr)
    <=> ( v9261(VarCurr)
        | v9224(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1748,axiom,
    ! [VarCurr] :
      ( v9261(VarCurr)
    <=> ( v9262(VarCurr)
        | v9223(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1747,axiom,
    ! [VarCurr] :
      ( v9262(VarCurr)
    <=> ( v9263(VarCurr)
        | v9222(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1746,axiom,
    ! [VarCurr] :
      ( v9263(VarCurr)
    <=> ( v9264(VarCurr)
        | v9215(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1745,axiom,
    ! [VarCurr] :
      ( v9264(VarCurr)
    <=> ( v9265(VarCurr)
        | v9214(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1744,axiom,
    ! [VarCurr] :
      ( v9265(VarCurr)
    <=> ( v9266(VarCurr)
        | v9213(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1743,axiom,
    ! [VarCurr] :
      ( v9266(VarCurr)
    <=> ( v9267(VarCurr)
        | v9212(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1742,axiom,
    ! [VarCurr] :
      ( v9267(VarCurr)
    <=> ( v9205(VarCurr)
        | v9211(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1741,axiom,
    ! [VarCurr] :
      ( v9245(VarCurr)
    <=> ( v9246(VarCurr)
        | v9256(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1740,axiom,
    ! [VarCurr] :
      ( v9256(VarCurr)
    <=> ( v9228(VarCurr)
        & v9226(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1739,axiom,
    ! [VarCurr] :
      ( v9246(VarCurr)
    <=> ( v9247(VarCurr)
        | v9225(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1738,axiom,
    ! [VarCurr] :
      ( v9247(VarCurr)
    <=> ( v9248(VarCurr)
        | v9224(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1737,axiom,
    ! [VarCurr] :
      ( v9248(VarCurr)
    <=> ( v9249(VarCurr)
        | v9223(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1736,axiom,
    ! [VarCurr] :
      ( v9249(VarCurr)
    <=> ( v9250(VarCurr)
        | v9222(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1735,axiom,
    ! [VarCurr] :
      ( v9250(VarCurr)
    <=> ( v9251(VarCurr)
        | v9255(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1734,axiom,
    ! [VarCurr] :
      ( v9255(VarCurr)
    <=> ( v9217(VarCurr)
        & v9215(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1733,axiom,
    ! [VarCurr] :
      ( v9251(VarCurr)
    <=> ( v9252(VarCurr)
        | v9214(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1732,axiom,
    ! [VarCurr] :
      ( v9252(VarCurr)
    <=> ( v9253(VarCurr)
        | v9213(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1731,axiom,
    ! [VarCurr] :
      ( v9253(VarCurr)
    <=> ( v9254(VarCurr)
        | v9212(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1730,axiom,
    ! [VarCurr] :
      ( v9254(VarCurr)
    <=> ( v9205(VarCurr)
        | v9211(VarCurr) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_146,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9231(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v3036(VarNext,B)
            <=> v3036(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_160,axiom,
    ! [VarNext] :
      ( v9231(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v3036(VarNext,B)
          <=> v9239(VarNext,B) ) ) ) ).

fof(addAssignment_2138,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v9239(VarNext,B)
          <=> v9237(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_234,axiom,
    ! [VarCurr] :
      ( ~ v9240(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9237(VarCurr,B)
          <=> v3038(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_237,axiom,
    ! [VarCurr] :
      ( v9240(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9237(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_806,axiom,
    ! [VarCurr] :
      ( ~ v9240(VarCurr)
    <=> v3030(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1729,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9231(VarNext)
      <=> v9232(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1728,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9232(VarNext)
      <=> ( v9233(VarNext)
          & v9185(VarNext) ) ) ) ).

fof(writeUnaryOperator_805,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9233(VarNext)
      <=> v9194(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges5_7,axiom,
    ! [VarCurr] :
      ( ( ~ v9205(VarCurr)
        & ~ v9207(VarCurr)
        & ~ v9215(VarCurr)
        & ~ v9218(VarCurr)
        & ~ v9226(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v3038(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges4_11,axiom,
    ! [VarCurr] :
      ( v9226(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v3038(VarCurr,B)
          <=> v9227(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_41,axiom,
    ! [VarCurr] :
      ( v9218(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v3038(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_89,axiom,
    ! [VarCurr] :
      ( v9215(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v3038(VarCurr,B)
          <=> v9216(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_227,axiom,
    ! [VarCurr] :
      ( v9207(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v3038(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_214,axiom,
    ! [VarCurr] :
      ( v9205(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v3038(VarCurr,B)
          <=> v9206(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_233,axiom,
    ! [VarCurr] :
      ( ~ v9228(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9227(VarCurr,B)
          <=> $false ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_236,axiom,
    ! [VarCurr] :
      ( v9228(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9227(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_804,axiom,
    ! [VarCurr] :
      ( ~ v9228(VarCurr)
    <=> v9181(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_659,axiom,
    ! [VarCurr] :
      ( v9226(VarCurr)
    <=> ( ( v3036(VarCurr,bitIndex3)
        <=> $true )
        & ( v3036(VarCurr,bitIndex2)
        <=> $true )
        & ( v3036(VarCurr,bitIndex1)
        <=> $false )
        & ( v3036(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1727,axiom,
    ! [VarCurr] :
      ( v9218(VarCurr)
    <=> ( v9220(VarCurr)
        | v9225(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_658,axiom,
    ! [VarCurr] :
      ( v9225(VarCurr)
    <=> ( ( v3036(VarCurr,bitIndex3)
        <=> $true )
        & ( v3036(VarCurr,bitIndex2)
        <=> $true )
        & ( v3036(VarCurr,bitIndex1)
        <=> $false )
        & ( v3036(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1726,axiom,
    ! [VarCurr] :
      ( v9220(VarCurr)
    <=> ( v9221(VarCurr)
        | v9224(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_657,axiom,
    ! [VarCurr] :
      ( v9224(VarCurr)
    <=> ( ( v3036(VarCurr,bitIndex3)
        <=> $true )
        & ( v3036(VarCurr,bitIndex2)
        <=> $false )
        & ( v3036(VarCurr,bitIndex1)
        <=> $true )
        & ( v3036(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1725,axiom,
    ! [VarCurr] :
      ( v9221(VarCurr)
    <=> ( v9222(VarCurr)
        | v9223(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_656,axiom,
    ! [VarCurr] :
      ( v9223(VarCurr)
    <=> ( ( v3036(VarCurr,bitIndex3)
        <=> $true )
        & ( v3036(VarCurr,bitIndex2)
        <=> $false )
        & ( v3036(VarCurr,bitIndex1)
        <=> $true )
        & ( v3036(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_655,axiom,
    ! [VarCurr] :
      ( v9222(VarCurr)
    <=> ( ( v3036(VarCurr,bitIndex3)
        <=> $true )
        & ( v3036(VarCurr,bitIndex2)
        <=> $false )
        & ( v3036(VarCurr,bitIndex1)
        <=> $false )
        & ( v3036(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_232,axiom,
    ! [VarCurr] :
      ( ~ v9217(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9216(VarCurr,B)
          <=> $false ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_235,axiom,
    ! [VarCurr] :
      ( v9217(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9216(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_803,axiom,
    ! [VarCurr] :
      ( ~ v9217(VarCurr)
    <=> v9181(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_654,axiom,
    ! [VarCurr] :
      ( v9215(VarCurr)
    <=> ( ( v3036(VarCurr,bitIndex3)
        <=> $false )
        & ( v3036(VarCurr,bitIndex2)
        <=> $true )
        & ( v3036(VarCurr,bitIndex1)
        <=> $false )
        & ( v3036(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1724,axiom,
    ! [VarCurr] :
      ( v9207(VarCurr)
    <=> ( v9209(VarCurr)
        | v9214(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_653,axiom,
    ! [VarCurr] :
      ( v9214(VarCurr)
    <=> ( ( v3036(VarCurr,bitIndex3)
        <=> $false )
        & ( v3036(VarCurr,bitIndex2)
        <=> $true )
        & ( v3036(VarCurr,bitIndex1)
        <=> $false )
        & ( v3036(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1723,axiom,
    ! [VarCurr] :
      ( v9209(VarCurr)
    <=> ( v9210(VarCurr)
        | v9213(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_652,axiom,
    ! [VarCurr] :
      ( v9213(VarCurr)
    <=> ( ( v3036(VarCurr,bitIndex3)
        <=> $false )
        & ( v3036(VarCurr,bitIndex2)
        <=> $false )
        & ( v3036(VarCurr,bitIndex1)
        <=> $true )
        & ( v3036(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1722,axiom,
    ! [VarCurr] :
      ( v9210(VarCurr)
    <=> ( v9211(VarCurr)
        | v9212(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_651,axiom,
    ! [VarCurr] :
      ( v9212(VarCurr)
    <=> ( ( v3036(VarCurr,bitIndex3)
        <=> $false )
        & ( v3036(VarCurr,bitIndex2)
        <=> $false )
        & ( v3036(VarCurr,bitIndex1)
        <=> $true )
        & ( v3036(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_650,axiom,
    ! [VarCurr] :
      ( v9211(VarCurr)
    <=> ( ( v3036(VarCurr,bitIndex3)
        <=> $false )
        & ( v3036(VarCurr,bitIndex2)
        <=> $false )
        & ( v3036(VarCurr,bitIndex1)
        <=> $false )
        & ( v3036(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_231,axiom,
    ! [VarCurr] :
      ( ~ v3040(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9206(VarCurr,B)
          <=> $false ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_234,axiom,
    ! [VarCurr] :
      ( v3040(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9206(VarCurr,B)
          <=> v9145(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_649,axiom,
    ! [VarCurr] :
      ( v9205(VarCurr)
    <=> ( ( v3036(VarCurr,bitIndex3)
        <=> $false )
        & ( v3036(VarCurr,bitIndex2)
        <=> $false )
        & ( v3036(VarCurr,bitIndex1)
        <=> $false )
        & ( v3036(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignmentInitValueVector_42,axiom,
    ! [B] :
      ( range_3_0(B)
     => ( v3036(constB0,B)
      <=> $false ) ) ).

fof(addCaseBooleanConditionEqualRanges1_145,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9190(VarNext)
       => ( v9181(VarNext)
        <=> v9181(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_159,axiom,
    ! [VarNext] :
      ( v9190(VarNext)
     => ( v9181(VarNext)
      <=> v9200(VarNext) ) ) ).

fof(addAssignment_2137,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9200(VarNext)
      <=> v9198(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_230,axiom,
    ! [VarCurr] :
      ( ~ v9201(VarCurr)
     => ( v9198(VarCurr)
      <=> v9183(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_233,axiom,
    ! [VarCurr] :
      ( v9201(VarCurr)
     => ( v9198(VarCurr)
      <=> $false ) ) ).

fof(writeUnaryOperator_802,axiom,
    ! [VarCurr] :
      ( ~ v9201(VarCurr)
    <=> v3030(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1721,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9190(VarNext)
      <=> v9191(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1720,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9191(VarNext)
      <=> ( v9192(VarNext)
          & v9185(VarNext) ) ) ) ).

fof(writeUnaryOperator_801,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9192(VarNext)
      <=> v9194(VarNext) ) ) ).

fof(addAssignment_2136,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9194(VarNext)
      <=> v9185(VarCurr) ) ) ).

fof(addAssignmentInitValueVector_41,axiom,
    ( v9181(constB0)
  <=> $false ) ).

fof(addAssignment_2135,axiom,
    ! [VarCurr] :
      ( v9185(VarCurr)
    <=> v9187(VarCurr) ) ).

fof(addAssignment_2134,axiom,
    ! [VarCurr] :
      ( v9187(VarCurr)
    <=> v1(VarCurr) ) ).

fof(addAssignment_2133,axiom,
    ! [VarCurr] :
      ( v9183(VarCurr)
    <=> $false ) ).

fof(addAssignment_2132,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v9145(VarCurr,B)
      <=> v9147(VarCurr,B) ) ) ).

fof(addAssignment_2131,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v9147(VarCurr,B)
      <=> v9149(VarCurr,B) ) ) ).

fof(addAssignment_2130,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v9149(VarCurr,B)
      <=> v9151(VarCurr,B) ) ) ).

fof(addAssignment_2129,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v9151(VarCurr,B)
      <=> v9153(VarCurr,B) ) ) ).

fof(addAssignment_2128,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v9153(VarCurr,B)
      <=> v9155(VarCurr,B) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_144,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9169(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v9155(VarNext,B)
            <=> v9155(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_158,axiom,
    ! [VarNext] :
      ( v9169(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v9155(VarNext,B)
          <=> v9177(VarNext,B) ) ) ) ).

fof(addAssignment_2127,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v9177(VarNext,B)
          <=> v9175(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_229,axiom,
    ! [VarCurr] :
      ( ~ v9141(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9175(VarCurr,B)
          <=> v9157(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_232,axiom,
    ! [VarCurr] :
      ( v9141(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9175(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1719,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9169(VarNext)
      <=> v9170(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1718,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9170(VarNext)
      <=> ( v9172(VarNext)
          & v9127(VarNext) ) ) ) ).

fof(writeUnaryOperator_800,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9172(VarNext)
      <=> v9134(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_228,axiom,
    ! [VarCurr] :
      ( ~ v9159(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9157(VarCurr,B)
          <=> $false ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_231,axiom,
    ! [VarCurr] :
      ( v9159(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9157(VarCurr,B)
          <=> v9162(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_40,axiom,
    ! [VarCurr] :
      ( ( ~ v9110(VarCurr)
        & ~ v9111(VarCurr)
        & ~ v9112(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v9162(VarCurr,B)
          <=> v9166(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_88,axiom,
    ! [VarCurr] :
      ( v9112(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9162(VarCurr,B)
          <=> v9165(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_226,axiom,
    ! [VarCurr] :
      ( v9111(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9162(VarCurr,B)
          <=> v9164(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_213,axiom,
    ! [VarCurr] :
      ( v9110(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9162(VarCurr,B)
          <=> v9163(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_227,axiom,
    ! [VarCurr] :
      ( ~ v3018(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9166(VarCurr,B)
          <=> b0011(B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_230,axiom,
    ! [VarCurr] :
      ( v3018(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9166(VarCurr,B)
          <=> $false ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_226,axiom,
    ! [VarCurr] :
      ( ~ v3018(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9165(VarCurr,B)
          <=> b0100(B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_229,axiom,
    ! [VarCurr] :
      ( v3018(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9165(VarCurr,B)
          <=> $false ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_225,axiom,
    ! [VarCurr] :
      ( ~ v3018(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9164(VarCurr,B)
          <=> b0001(B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_228,axiom,
    ! [VarCurr] :
      ( v3018(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9164(VarCurr,B)
          <=> b0100(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_87,axiom,
    ! [VarCurr] :
      ( ( ~ v9116(VarCurr)
        & ~ v9119(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v9163(VarCurr,B)
          <=> b0011(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_225,axiom,
    ! [VarCurr] :
      ( v9119(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9163(VarCurr,B)
          <=> b0001(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_212,axiom,
    ! [VarCurr] :
      ( v9116(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v9163(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1717,axiom,
    ! [VarCurr] :
      ( v9159(VarCurr)
    <=> ( v9160(VarCurr)
        | v9113(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1716,axiom,
    ! [VarCurr] :
      ( v9160(VarCurr)
    <=> ( v9161(VarCurr)
        | v9112(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1715,axiom,
    ! [VarCurr] :
      ( v9161(VarCurr)
    <=> ( v9110(VarCurr)
        | v9111(VarCurr) ) ) ).

fof(addAssignment_2126,axiom,
    ! [VarCurr] :
      ( v3040(VarCurr)
    <=> v3042(VarCurr) ) ).

fof(addAssignment_2125,axiom,
    ! [VarCurr] :
      ( v3042(VarCurr)
    <=> v3044(VarCurr) ) ).

fof(addAssignment_2124,axiom,
    ! [VarCurr] :
      ( v3044(VarCurr)
    <=> v3046(VarCurr) ) ).

fof(addAssignment_2123,axiom,
    ! [VarCurr] :
      ( v3046(VarCurr)
    <=> v3048(VarCurr) ) ).

fof(addAssignment_2122,axiom,
    ! [VarCurr] :
      ( v3048(VarCurr)
    <=> v3050(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_143,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9130(VarNext)
       => ( v3050(VarNext)
        <=> v3050(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_157,axiom,
    ! [VarNext] :
      ( v9130(VarNext)
     => ( v3050(VarNext)
      <=> v9140(VarNext) ) ) ).

fof(addAssignment_2121,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9140(VarNext)
      <=> v9138(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_224,axiom,
    ! [VarCurr] :
      ( ~ v9141(VarCurr)
     => ( v9138(VarCurr)
      <=> v3052(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_227,axiom,
    ! [VarCurr] :
      ( v9141(VarCurr)
     => ( v9138(VarCurr)
      <=> $false ) ) ).

fof(writeUnaryOperator_799,axiom,
    ! [VarCurr] :
      ( ~ v9141(VarCurr)
    <=> v8(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1714,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9130(VarNext)
      <=> v9131(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1713,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9131(VarNext)
      <=> ( v9132(VarNext)
          & v9127(VarNext) ) ) ) ).

fof(writeUnaryOperator_798,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9132(VarNext)
      <=> v9134(VarNext) ) ) ).

fof(addAssignment_2120,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9134(VarNext)
      <=> v9127(VarCurr) ) ) ).

fof(addAssignment_2119,axiom,
    ! [VarCurr] :
      ( v9127(VarCurr)
    <=> v3084(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_223,axiom,
    ! [VarCurr] :
      ( ~ v9107(VarCurr)
     => ( v3052(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_226,axiom,
    ! [VarCurr] :
      ( v9107(VarCurr)
     => ( v3052(VarCurr)
      <=> v9114(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_86,axiom,
    ! [VarCurr] :
      ( ( ~ v9110(VarCurr)
        & ~ v9111(VarCurr) )
     => ( v9114(VarCurr)
      <=> v9125(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_224,axiom,
    ! [VarCurr] :
      ( v9111(VarCurr)
     => ( v9114(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_211,axiom,
    ! [VarCurr] :
      ( v9110(VarCurr)
     => ( v9114(VarCurr)
      <=> v9115(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_222,axiom,
    ! [VarCurr] :
      ( ~ v3018(VarCurr)
     => ( v9125(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_225,axiom,
    ! [VarCurr] :
      ( v3018(VarCurr)
     => ( v9125(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1712,axiom,
    ! [VarCurr] :
      ( v9124(VarCurr)
    <=> ( v9112(VarCurr)
        | v9113(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_223,axiom,
    ! [VarCurr] :
      ( ~ v9116(VarCurr)
     => ( v9115(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_210,axiom,
    ! [VarCurr] :
      ( v9116(VarCurr)
     => ( v9115(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1711,axiom,
    ! [VarCurr] :
      ( v9118(VarCurr)
    <=> ( v9119(VarCurr)
        | v9122(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1710,axiom,
    ! [VarCurr] :
      ( v9122(VarCurr)
    <=> ( v21(VarCurr)
        & v3054(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1709,axiom,
    ! [VarCurr] :
      ( v9119(VarCurr)
    <=> ( v21(VarCurr)
        & v9121(VarCurr) ) ) ).

fof(writeUnaryOperator_797,axiom,
    ! [VarCurr] :
      ( ~ v9121(VarCurr)
    <=> v3054(VarCurr) ) ).

fof(writeUnaryOperator_796,axiom,
    ! [VarCurr] :
      ( ~ v9116(VarCurr)
    <=> v21(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1708,axiom,
    ! [VarCurr] :
      ( v9107(VarCurr)
    <=> ( v9108(VarCurr)
        | v9113(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_648,axiom,
    ! [VarCurr] :
      ( v9113(VarCurr)
    <=> ( $true
      <=> v6(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1707,axiom,
    ! [VarCurr] :
      ( v9108(VarCurr)
    <=> ( v9109(VarCurr)
        | v9112(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_647,axiom,
    ! [VarCurr] :
      ( v9112(VarCurr)
    <=> ( $true
      <=> v6(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1706,axiom,
    ! [VarCurr] :
      ( v9109(VarCurr)
    <=> ( v9110(VarCurr)
        | v9111(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_646,axiom,
    ! [VarCurr] :
      ( v9111(VarCurr)
    <=> ( $true
      <=> v6(VarCurr,bitIndex2) ) ) ).

fof(addBitVectorEqualityBitBlasted_645,axiom,
    ! [VarCurr] :
      ( v9110(VarCurr)
    <=> ( $true
      <=> v6(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_2118,axiom,
    ! [VarCurr] :
      ( v3054(VarCurr)
    <=> v3056(VarCurr) ) ).

fof(addAssignment_2117,axiom,
    ! [VarCurr] :
      ( v3056(VarCurr)
    <=> v3058(VarCurr) ) ).

fof(addAssignment_2116,axiom,
    ! [VarCurr] :
      ( v3058(VarCurr)
    <=> v3060(VarCurr,bitIndex0) ) ).

fof(addAssignment_2115,axiom,
    ! [VarCurr] :
      ( v3060(VarCurr,bitIndex0)
    <=> v3062(VarCurr,bitIndex49) ) ).

fof(addAssignment_2114,axiom,
    ! [VarCurr] :
      ( v3062(VarCurr,bitIndex49)
    <=> v3064(VarCurr,bitIndex49) ) ).

fof(addAssignment_2113,axiom,
    ! [VarCurr] :
      ( v3064(VarCurr,bitIndex49)
    <=> v3066(VarCurr,bitIndex539) ) ).

fof(addAssignment_2112,axiom,
    ! [VarNext] :
      ( v3066(VarNext,bitIndex539)
    <=> v9074(VarNext,bitIndex49) ) ).

fof(addCaseBooleanConditionShiftedRanges1_22,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9075(VarNext)
       => ( ( v9074(VarNext,bitIndex69)
          <=> v3066(VarCurr,bitIndex559) )
          & ( v9074(VarNext,bitIndex68)
          <=> v3066(VarCurr,bitIndex558) )
          & ( v9074(VarNext,bitIndex67)
          <=> v3066(VarCurr,bitIndex557) )
          & ( v9074(VarNext,bitIndex66)
          <=> v3066(VarCurr,bitIndex556) )
          & ( v9074(VarNext,bitIndex65)
          <=> v3066(VarCurr,bitIndex555) )
          & ( v9074(VarNext,bitIndex64)
          <=> v3066(VarCurr,bitIndex554) )
          & ( v9074(VarNext,bitIndex63)
          <=> v3066(VarCurr,bitIndex553) )
          & ( v9074(VarNext,bitIndex62)
          <=> v3066(VarCurr,bitIndex552) )
          & ( v9074(VarNext,bitIndex61)
          <=> v3066(VarCurr,bitIndex551) )
          & ( v9074(VarNext,bitIndex60)
          <=> v3066(VarCurr,bitIndex550) )
          & ( v9074(VarNext,bitIndex59)
          <=> v3066(VarCurr,bitIndex549) )
          & ( v9074(VarNext,bitIndex58)
          <=> v3066(VarCurr,bitIndex548) )
          & ( v9074(VarNext,bitIndex57)
          <=> v3066(VarCurr,bitIndex547) )
          & ( v9074(VarNext,bitIndex56)
          <=> v3066(VarCurr,bitIndex546) )
          & ( v9074(VarNext,bitIndex55)
          <=> v3066(VarCurr,bitIndex545) )
          & ( v9074(VarNext,bitIndex54)
          <=> v3066(VarCurr,bitIndex544) )
          & ( v9074(VarNext,bitIndex53)
          <=> v3066(VarCurr,bitIndex543) )
          & ( v9074(VarNext,bitIndex52)
          <=> v3066(VarCurr,bitIndex542) )
          & ( v9074(VarNext,bitIndex51)
          <=> v3066(VarCurr,bitIndex541) )
          & ( v9074(VarNext,bitIndex50)
          <=> v3066(VarCurr,bitIndex540) )
          & ( v9074(VarNext,bitIndex49)
          <=> v3066(VarCurr,bitIndex539) )
          & ( v9074(VarNext,bitIndex48)
          <=> v3066(VarCurr,bitIndex538) )
          & ( v9074(VarNext,bitIndex47)
          <=> v3066(VarCurr,bitIndex537) )
          & ( v9074(VarNext,bitIndex46)
          <=> v3066(VarCurr,bitIndex536) )
          & ( v9074(VarNext,bitIndex45)
          <=> v3066(VarCurr,bitIndex535) )
          & ( v9074(VarNext,bitIndex44)
          <=> v3066(VarCurr,bitIndex534) )
          & ( v9074(VarNext,bitIndex43)
          <=> v3066(VarCurr,bitIndex533) )
          & ( v9074(VarNext,bitIndex42)
          <=> v3066(VarCurr,bitIndex532) )
          & ( v9074(VarNext,bitIndex41)
          <=> v3066(VarCurr,bitIndex531) )
          & ( v9074(VarNext,bitIndex40)
          <=> v3066(VarCurr,bitIndex530) )
          & ( v9074(VarNext,bitIndex39)
          <=> v3066(VarCurr,bitIndex529) )
          & ( v9074(VarNext,bitIndex38)
          <=> v3066(VarCurr,bitIndex528) )
          & ( v9074(VarNext,bitIndex37)
          <=> v3066(VarCurr,bitIndex527) )
          & ( v9074(VarNext,bitIndex36)
          <=> v3066(VarCurr,bitIndex526) )
          & ( v9074(VarNext,bitIndex35)
          <=> v3066(VarCurr,bitIndex525) )
          & ( v9074(VarNext,bitIndex34)
          <=> v3066(VarCurr,bitIndex524) )
          & ( v9074(VarNext,bitIndex33)
          <=> v3066(VarCurr,bitIndex523) )
          & ( v9074(VarNext,bitIndex32)
          <=> v3066(VarCurr,bitIndex522) )
          & ( v9074(VarNext,bitIndex31)
          <=> v3066(VarCurr,bitIndex521) )
          & ( v9074(VarNext,bitIndex30)
          <=> v3066(VarCurr,bitIndex520) )
          & ( v9074(VarNext,bitIndex29)
          <=> v3066(VarCurr,bitIndex519) )
          & ( v9074(VarNext,bitIndex28)
          <=> v3066(VarCurr,bitIndex518) )
          & ( v9074(VarNext,bitIndex27)
          <=> v3066(VarCurr,bitIndex517) )
          & ( v9074(VarNext,bitIndex26)
          <=> v3066(VarCurr,bitIndex516) )
          & ( v9074(VarNext,bitIndex25)
          <=> v3066(VarCurr,bitIndex515) )
          & ( v9074(VarNext,bitIndex24)
          <=> v3066(VarCurr,bitIndex514) )
          & ( v9074(VarNext,bitIndex23)
          <=> v3066(VarCurr,bitIndex513) )
          & ( v9074(VarNext,bitIndex22)
          <=> v3066(VarCurr,bitIndex512) )
          & ( v9074(VarNext,bitIndex21)
          <=> v3066(VarCurr,bitIndex511) )
          & ( v9074(VarNext,bitIndex20)
          <=> v3066(VarCurr,bitIndex510) )
          & ( v9074(VarNext,bitIndex19)
          <=> v3066(VarCurr,bitIndex509) )
          & ( v9074(VarNext,bitIndex18)
          <=> v3066(VarCurr,bitIndex508) )
          & ( v9074(VarNext,bitIndex17)
          <=> v3066(VarCurr,bitIndex507) )
          & ( v9074(VarNext,bitIndex16)
          <=> v3066(VarCurr,bitIndex506) )
          & ( v9074(VarNext,bitIndex15)
          <=> v3066(VarCurr,bitIndex505) )
          & ( v9074(VarNext,bitIndex14)
          <=> v3066(VarCurr,bitIndex504) )
          & ( v9074(VarNext,bitIndex13)
          <=> v3066(VarCurr,bitIndex503) )
          & ( v9074(VarNext,bitIndex12)
          <=> v3066(VarCurr,bitIndex502) )
          & ( v9074(VarNext,bitIndex11)
          <=> v3066(VarCurr,bitIndex501) )
          & ( v9074(VarNext,bitIndex10)
          <=> v3066(VarCurr,bitIndex500) )
          & ( v9074(VarNext,bitIndex9)
          <=> v3066(VarCurr,bitIndex499) )
          & ( v9074(VarNext,bitIndex8)
          <=> v3066(VarCurr,bitIndex498) )
          & ( v9074(VarNext,bitIndex7)
          <=> v3066(VarCurr,bitIndex497) )
          & ( v9074(VarNext,bitIndex6)
          <=> v3066(VarCurr,bitIndex496) )
          & ( v9074(VarNext,bitIndex5)
          <=> v3066(VarCurr,bitIndex495) )
          & ( v9074(VarNext,bitIndex4)
          <=> v3066(VarCurr,bitIndex494) )
          & ( v9074(VarNext,bitIndex3)
          <=> v3066(VarCurr,bitIndex493) )
          & ( v9074(VarNext,bitIndex2)
          <=> v3066(VarCurr,bitIndex492) )
          & ( v9074(VarNext,bitIndex1)
          <=> v3066(VarCurr,bitIndex491) )
          & ( v9074(VarNext,bitIndex0)
          <=> v3066(VarCurr,bitIndex490) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_156,axiom,
    ! [VarNext] :
      ( v9075(VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v9074(VarNext,B)
          <=> v9101(VarNext,B) ) ) ) ).

fof(addAssignment_2111,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v9101(VarNext,B)
          <=> v9099(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_222,axiom,
    ! [VarCurr] :
      ( ~ v8900(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9099(VarCurr,B)
          <=> v9102(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_209,axiom,
    ! [VarCurr] :
      ( v8900(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9099(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_85,axiom,
    ! [VarCurr] :
      ( ( ~ v9088(VarCurr)
        & ~ v9090(VarCurr) )
     => ! [B] :
          ( range_69_0(B)
         => ( v9102(VarCurr,B)
          <=> v9067(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_221,axiom,
    ! [VarCurr] :
      ( v9090(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9102(VarCurr,B)
          <=> v9060(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0_14,axiom,
    ! [VarCurr] :
      ( v9088(VarCurr)
     => ( ( v9102(VarCurr,bitIndex69)
        <=> v3066(VarCurr,bitIndex489) )
        & ( v9102(VarCurr,bitIndex68)
        <=> v3066(VarCurr,bitIndex488) )
        & ( v9102(VarCurr,bitIndex67)
        <=> v3066(VarCurr,bitIndex487) )
        & ( v9102(VarCurr,bitIndex66)
        <=> v3066(VarCurr,bitIndex486) )
        & ( v9102(VarCurr,bitIndex65)
        <=> v3066(VarCurr,bitIndex485) )
        & ( v9102(VarCurr,bitIndex64)
        <=> v3066(VarCurr,bitIndex484) )
        & ( v9102(VarCurr,bitIndex63)
        <=> v3066(VarCurr,bitIndex483) )
        & ( v9102(VarCurr,bitIndex62)
        <=> v3066(VarCurr,bitIndex482) )
        & ( v9102(VarCurr,bitIndex61)
        <=> v3066(VarCurr,bitIndex481) )
        & ( v9102(VarCurr,bitIndex60)
        <=> v3066(VarCurr,bitIndex480) )
        & ( v9102(VarCurr,bitIndex59)
        <=> v3066(VarCurr,bitIndex479) )
        & ( v9102(VarCurr,bitIndex58)
        <=> v3066(VarCurr,bitIndex478) )
        & ( v9102(VarCurr,bitIndex57)
        <=> v3066(VarCurr,bitIndex477) )
        & ( v9102(VarCurr,bitIndex56)
        <=> v3066(VarCurr,bitIndex476) )
        & ( v9102(VarCurr,bitIndex55)
        <=> v3066(VarCurr,bitIndex475) )
        & ( v9102(VarCurr,bitIndex54)
        <=> v3066(VarCurr,bitIndex474) )
        & ( v9102(VarCurr,bitIndex53)
        <=> v3066(VarCurr,bitIndex473) )
        & ( v9102(VarCurr,bitIndex52)
        <=> v3066(VarCurr,bitIndex472) )
        & ( v9102(VarCurr,bitIndex51)
        <=> v3066(VarCurr,bitIndex471) )
        & ( v9102(VarCurr,bitIndex50)
        <=> v3066(VarCurr,bitIndex470) )
        & ( v9102(VarCurr,bitIndex49)
        <=> v3066(VarCurr,bitIndex469) )
        & ( v9102(VarCurr,bitIndex48)
        <=> v3066(VarCurr,bitIndex468) )
        & ( v9102(VarCurr,bitIndex47)
        <=> v3066(VarCurr,bitIndex467) )
        & ( v9102(VarCurr,bitIndex46)
        <=> v3066(VarCurr,bitIndex466) )
        & ( v9102(VarCurr,bitIndex45)
        <=> v3066(VarCurr,bitIndex465) )
        & ( v9102(VarCurr,bitIndex44)
        <=> v3066(VarCurr,bitIndex464) )
        & ( v9102(VarCurr,bitIndex43)
        <=> v3066(VarCurr,bitIndex463) )
        & ( v9102(VarCurr,bitIndex42)
        <=> v3066(VarCurr,bitIndex462) )
        & ( v9102(VarCurr,bitIndex41)
        <=> v3066(VarCurr,bitIndex461) )
        & ( v9102(VarCurr,bitIndex40)
        <=> v3066(VarCurr,bitIndex460) )
        & ( v9102(VarCurr,bitIndex39)
        <=> v3066(VarCurr,bitIndex459) )
        & ( v9102(VarCurr,bitIndex38)
        <=> v3066(VarCurr,bitIndex458) )
        & ( v9102(VarCurr,bitIndex37)
        <=> v3066(VarCurr,bitIndex457) )
        & ( v9102(VarCurr,bitIndex36)
        <=> v3066(VarCurr,bitIndex456) )
        & ( v9102(VarCurr,bitIndex35)
        <=> v3066(VarCurr,bitIndex455) )
        & ( v9102(VarCurr,bitIndex34)
        <=> v3066(VarCurr,bitIndex454) )
        & ( v9102(VarCurr,bitIndex33)
        <=> v3066(VarCurr,bitIndex453) )
        & ( v9102(VarCurr,bitIndex32)
        <=> v3066(VarCurr,bitIndex452) )
        & ( v9102(VarCurr,bitIndex31)
        <=> v3066(VarCurr,bitIndex451) )
        & ( v9102(VarCurr,bitIndex30)
        <=> v3066(VarCurr,bitIndex450) )
        & ( v9102(VarCurr,bitIndex29)
        <=> v3066(VarCurr,bitIndex449) )
        & ( v9102(VarCurr,bitIndex28)
        <=> v3066(VarCurr,bitIndex448) )
        & ( v9102(VarCurr,bitIndex27)
        <=> v3066(VarCurr,bitIndex447) )
        & ( v9102(VarCurr,bitIndex26)
        <=> v3066(VarCurr,bitIndex446) )
        & ( v9102(VarCurr,bitIndex25)
        <=> v3066(VarCurr,bitIndex445) )
        & ( v9102(VarCurr,bitIndex24)
        <=> v3066(VarCurr,bitIndex444) )
        & ( v9102(VarCurr,bitIndex23)
        <=> v3066(VarCurr,bitIndex443) )
        & ( v9102(VarCurr,bitIndex22)
        <=> v3066(VarCurr,bitIndex442) )
        & ( v9102(VarCurr,bitIndex21)
        <=> v3066(VarCurr,bitIndex441) )
        & ( v9102(VarCurr,bitIndex20)
        <=> v3066(VarCurr,bitIndex440) )
        & ( v9102(VarCurr,bitIndex19)
        <=> v3066(VarCurr,bitIndex439) )
        & ( v9102(VarCurr,bitIndex18)
        <=> v3066(VarCurr,bitIndex438) )
        & ( v9102(VarCurr,bitIndex17)
        <=> v3066(VarCurr,bitIndex437) )
        & ( v9102(VarCurr,bitIndex16)
        <=> v3066(VarCurr,bitIndex436) )
        & ( v9102(VarCurr,bitIndex15)
        <=> v3066(VarCurr,bitIndex435) )
        & ( v9102(VarCurr,bitIndex14)
        <=> v3066(VarCurr,bitIndex434) )
        & ( v9102(VarCurr,bitIndex13)
        <=> v3066(VarCurr,bitIndex433) )
        & ( v9102(VarCurr,bitIndex12)
        <=> v3066(VarCurr,bitIndex432) )
        & ( v9102(VarCurr,bitIndex11)
        <=> v3066(VarCurr,bitIndex431) )
        & ( v9102(VarCurr,bitIndex10)
        <=> v3066(VarCurr,bitIndex430) )
        & ( v9102(VarCurr,bitIndex9)
        <=> v3066(VarCurr,bitIndex429) )
        & ( v9102(VarCurr,bitIndex8)
        <=> v3066(VarCurr,bitIndex428) )
        & ( v9102(VarCurr,bitIndex7)
        <=> v3066(VarCurr,bitIndex427) )
        & ( v9102(VarCurr,bitIndex6)
        <=> v3066(VarCurr,bitIndex426) )
        & ( v9102(VarCurr,bitIndex5)
        <=> v3066(VarCurr,bitIndex425) )
        & ( v9102(VarCurr,bitIndex4)
        <=> v3066(VarCurr,bitIndex424) )
        & ( v9102(VarCurr,bitIndex3)
        <=> v3066(VarCurr,bitIndex423) )
        & ( v9102(VarCurr,bitIndex2)
        <=> v3066(VarCurr,bitIndex422) )
        & ( v9102(VarCurr,bitIndex1)
        <=> v3066(VarCurr,bitIndex421) )
        & ( v9102(VarCurr,bitIndex0)
        <=> v3066(VarCurr,bitIndex420) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1705,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9075(VarNext)
      <=> ( v9076(VarNext)
          & v9083(VarNext) ) ) ) ).

fof(addAssignment_2110,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9083(VarNext)
      <=> v9081(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1704,axiom,
    ! [VarCurr] :
      ( v9081(VarCurr)
    <=> ( v9084(VarCurr)
        & v9095(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1703,axiom,
    ! [VarCurr] :
      ( v9095(VarCurr)
    <=> ( v9096(VarCurr)
        | v8900(VarCurr) ) ) ).

fof(writeUnaryOperator_795,axiom,
    ! [VarCurr] :
      ( ~ v9096(VarCurr)
    <=> v9097(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_644,axiom,
    ! [VarCurr] :
      ( v9097(VarCurr)
    <=> ( ( v9098(VarCurr,bitIndex1)
        <=> $false )
        & ( v9098(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2109,axiom,
    ! [VarCurr] :
      ( v9098(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2108,axiom,
    ! [VarCurr] :
      ( v9098(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1702,axiom,
    ! [VarCurr] :
      ( v9084(VarCurr)
    <=> ( v8900(VarCurr)
        | v9085(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1701,axiom,
    ! [VarCurr] :
      ( v9085(VarCurr)
    <=> ( v9086(VarCurr)
        & v9094(VarCurr) ) ) ).

fof(writeUnaryOperator_794,axiom,
    ! [VarCurr] :
      ( ~ v9094(VarCurr)
    <=> v8900(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1700,axiom,
    ! [VarCurr] :
      ( v9086(VarCurr)
    <=> ( v9087(VarCurr)
        | v9092(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_643,axiom,
    ! [VarCurr] :
      ( v9092(VarCurr)
    <=> ( ( v9093(VarCurr,bitIndex1)
        <=> $true )
        & ( v9093(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2107,axiom,
    ! [VarCurr] :
      ( v9093(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2106,axiom,
    ! [VarCurr] :
      ( v9093(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1699,axiom,
    ! [VarCurr] :
      ( v9087(VarCurr)
    <=> ( v9088(VarCurr)
        | v9090(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_642,axiom,
    ! [VarCurr] :
      ( v9090(VarCurr)
    <=> ( ( v9091(VarCurr,bitIndex1)
        <=> $true )
        & ( v9091(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2105,axiom,
    ! [VarCurr] :
      ( v9091(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2104,axiom,
    ! [VarCurr] :
      ( v9091(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_641,axiom,
    ! [VarCurr] :
      ( v9088(VarCurr)
    <=> ( ( v9089(VarCurr,bitIndex1)
        <=> $false )
        & ( v9089(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2103,axiom,
    ! [VarCurr] :
      ( v9089(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2102,axiom,
    ! [VarCurr] :
      ( v9089(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1698,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9076(VarNext)
      <=> ( v9078(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_793,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9078(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2101,axiom,
    ! [VarCurr] :
      ( v9067(VarCurr,bitIndex49)
    <=> v9072(VarCurr,bitIndex49) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_221,axiom,
    ! [VarCurr] :
      ( ~ v9069(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9072(VarCurr,B)
          <=> v9071(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_224,axiom,
    ! [VarCurr] :
      ( v9069(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9072(VarCurr,B)
          <=> v3163(VarCurr,B) ) ) ) ).

fof(addAssignment_2100,axiom,
    ! [VarCurr] :
      ( v9071(VarCurr,bitIndex49)
    <=> v3066(VarCurr,bitIndex469) ) ).

fof(addAssignment_2099,axiom,
    ! [VarCurr] :
      ( v9069(VarCurr)
    <=> v3073(VarCurr,bitIndex1) ) ).

fof(addAssignment_2098,axiom,
    ! [VarCurr] :
      ( v9060(VarCurr,bitIndex49)
    <=> v9065(VarCurr,bitIndex49) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_220,axiom,
    ! [VarCurr] :
      ( ~ v9062(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9065(VarCurr,B)
          <=> v9064(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_223,axiom,
    ! [VarCurr] :
      ( v9062(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9065(VarCurr,B)
          <=> v3163(VarCurr,B) ) ) ) ).

fof(addAssignment_2097,axiom,
    ! [VarCurr] :
      ( v9064(VarCurr,bitIndex49)
    <=> v3066(VarCurr,bitIndex539) ) ).

fof(addAssignment_2096,axiom,
    ! [VarCurr] :
      ( v9062(VarCurr)
    <=> v3073(VarCurr,bitIndex1) ) ).

fof(addAssignment_2095,axiom,
    ! [VarNext] :
      ( v3066(VarNext,bitIndex469)
    <=> v9028(VarNext,bitIndex49) ) ).

fof(addCaseBooleanConditionShiftedRanges1_21,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9029(VarNext)
       => ( ( v9028(VarNext,bitIndex69)
          <=> v3066(VarCurr,bitIndex489) )
          & ( v9028(VarNext,bitIndex68)
          <=> v3066(VarCurr,bitIndex488) )
          & ( v9028(VarNext,bitIndex67)
          <=> v3066(VarCurr,bitIndex487) )
          & ( v9028(VarNext,bitIndex66)
          <=> v3066(VarCurr,bitIndex486) )
          & ( v9028(VarNext,bitIndex65)
          <=> v3066(VarCurr,bitIndex485) )
          & ( v9028(VarNext,bitIndex64)
          <=> v3066(VarCurr,bitIndex484) )
          & ( v9028(VarNext,bitIndex63)
          <=> v3066(VarCurr,bitIndex483) )
          & ( v9028(VarNext,bitIndex62)
          <=> v3066(VarCurr,bitIndex482) )
          & ( v9028(VarNext,bitIndex61)
          <=> v3066(VarCurr,bitIndex481) )
          & ( v9028(VarNext,bitIndex60)
          <=> v3066(VarCurr,bitIndex480) )
          & ( v9028(VarNext,bitIndex59)
          <=> v3066(VarCurr,bitIndex479) )
          & ( v9028(VarNext,bitIndex58)
          <=> v3066(VarCurr,bitIndex478) )
          & ( v9028(VarNext,bitIndex57)
          <=> v3066(VarCurr,bitIndex477) )
          & ( v9028(VarNext,bitIndex56)
          <=> v3066(VarCurr,bitIndex476) )
          & ( v9028(VarNext,bitIndex55)
          <=> v3066(VarCurr,bitIndex475) )
          & ( v9028(VarNext,bitIndex54)
          <=> v3066(VarCurr,bitIndex474) )
          & ( v9028(VarNext,bitIndex53)
          <=> v3066(VarCurr,bitIndex473) )
          & ( v9028(VarNext,bitIndex52)
          <=> v3066(VarCurr,bitIndex472) )
          & ( v9028(VarNext,bitIndex51)
          <=> v3066(VarCurr,bitIndex471) )
          & ( v9028(VarNext,bitIndex50)
          <=> v3066(VarCurr,bitIndex470) )
          & ( v9028(VarNext,bitIndex49)
          <=> v3066(VarCurr,bitIndex469) )
          & ( v9028(VarNext,bitIndex48)
          <=> v3066(VarCurr,bitIndex468) )
          & ( v9028(VarNext,bitIndex47)
          <=> v3066(VarCurr,bitIndex467) )
          & ( v9028(VarNext,bitIndex46)
          <=> v3066(VarCurr,bitIndex466) )
          & ( v9028(VarNext,bitIndex45)
          <=> v3066(VarCurr,bitIndex465) )
          & ( v9028(VarNext,bitIndex44)
          <=> v3066(VarCurr,bitIndex464) )
          & ( v9028(VarNext,bitIndex43)
          <=> v3066(VarCurr,bitIndex463) )
          & ( v9028(VarNext,bitIndex42)
          <=> v3066(VarCurr,bitIndex462) )
          & ( v9028(VarNext,bitIndex41)
          <=> v3066(VarCurr,bitIndex461) )
          & ( v9028(VarNext,bitIndex40)
          <=> v3066(VarCurr,bitIndex460) )
          & ( v9028(VarNext,bitIndex39)
          <=> v3066(VarCurr,bitIndex459) )
          & ( v9028(VarNext,bitIndex38)
          <=> v3066(VarCurr,bitIndex458) )
          & ( v9028(VarNext,bitIndex37)
          <=> v3066(VarCurr,bitIndex457) )
          & ( v9028(VarNext,bitIndex36)
          <=> v3066(VarCurr,bitIndex456) )
          & ( v9028(VarNext,bitIndex35)
          <=> v3066(VarCurr,bitIndex455) )
          & ( v9028(VarNext,bitIndex34)
          <=> v3066(VarCurr,bitIndex454) )
          & ( v9028(VarNext,bitIndex33)
          <=> v3066(VarCurr,bitIndex453) )
          & ( v9028(VarNext,bitIndex32)
          <=> v3066(VarCurr,bitIndex452) )
          & ( v9028(VarNext,bitIndex31)
          <=> v3066(VarCurr,bitIndex451) )
          & ( v9028(VarNext,bitIndex30)
          <=> v3066(VarCurr,bitIndex450) )
          & ( v9028(VarNext,bitIndex29)
          <=> v3066(VarCurr,bitIndex449) )
          & ( v9028(VarNext,bitIndex28)
          <=> v3066(VarCurr,bitIndex448) )
          & ( v9028(VarNext,bitIndex27)
          <=> v3066(VarCurr,bitIndex447) )
          & ( v9028(VarNext,bitIndex26)
          <=> v3066(VarCurr,bitIndex446) )
          & ( v9028(VarNext,bitIndex25)
          <=> v3066(VarCurr,bitIndex445) )
          & ( v9028(VarNext,bitIndex24)
          <=> v3066(VarCurr,bitIndex444) )
          & ( v9028(VarNext,bitIndex23)
          <=> v3066(VarCurr,bitIndex443) )
          & ( v9028(VarNext,bitIndex22)
          <=> v3066(VarCurr,bitIndex442) )
          & ( v9028(VarNext,bitIndex21)
          <=> v3066(VarCurr,bitIndex441) )
          & ( v9028(VarNext,bitIndex20)
          <=> v3066(VarCurr,bitIndex440) )
          & ( v9028(VarNext,bitIndex19)
          <=> v3066(VarCurr,bitIndex439) )
          & ( v9028(VarNext,bitIndex18)
          <=> v3066(VarCurr,bitIndex438) )
          & ( v9028(VarNext,bitIndex17)
          <=> v3066(VarCurr,bitIndex437) )
          & ( v9028(VarNext,bitIndex16)
          <=> v3066(VarCurr,bitIndex436) )
          & ( v9028(VarNext,bitIndex15)
          <=> v3066(VarCurr,bitIndex435) )
          & ( v9028(VarNext,bitIndex14)
          <=> v3066(VarCurr,bitIndex434) )
          & ( v9028(VarNext,bitIndex13)
          <=> v3066(VarCurr,bitIndex433) )
          & ( v9028(VarNext,bitIndex12)
          <=> v3066(VarCurr,bitIndex432) )
          & ( v9028(VarNext,bitIndex11)
          <=> v3066(VarCurr,bitIndex431) )
          & ( v9028(VarNext,bitIndex10)
          <=> v3066(VarCurr,bitIndex430) )
          & ( v9028(VarNext,bitIndex9)
          <=> v3066(VarCurr,bitIndex429) )
          & ( v9028(VarNext,bitIndex8)
          <=> v3066(VarCurr,bitIndex428) )
          & ( v9028(VarNext,bitIndex7)
          <=> v3066(VarCurr,bitIndex427) )
          & ( v9028(VarNext,bitIndex6)
          <=> v3066(VarCurr,bitIndex426) )
          & ( v9028(VarNext,bitIndex5)
          <=> v3066(VarCurr,bitIndex425) )
          & ( v9028(VarNext,bitIndex4)
          <=> v3066(VarCurr,bitIndex424) )
          & ( v9028(VarNext,bitIndex3)
          <=> v3066(VarCurr,bitIndex423) )
          & ( v9028(VarNext,bitIndex2)
          <=> v3066(VarCurr,bitIndex422) )
          & ( v9028(VarNext,bitIndex1)
          <=> v3066(VarCurr,bitIndex421) )
          & ( v9028(VarNext,bitIndex0)
          <=> v3066(VarCurr,bitIndex420) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_155,axiom,
    ! [VarNext] :
      ( v9029(VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v9028(VarNext,B)
          <=> v9055(VarNext,B) ) ) ) ).

fof(addAssignment_2094,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v9055(VarNext,B)
          <=> v9053(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_220,axiom,
    ! [VarCurr] :
      ( ~ v8900(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9053(VarCurr,B)
          <=> v9056(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_208,axiom,
    ! [VarCurr] :
      ( v8900(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9053(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_84,axiom,
    ! [VarCurr] :
      ( ( ~ v9042(VarCurr)
        & ~ v9044(VarCurr) )
     => ! [B] :
          ( range_69_0(B)
         => ( v9056(VarCurr,B)
          <=> v9021(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_219,axiom,
    ! [VarCurr] :
      ( v9044(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9056(VarCurr,B)
          <=> v9014(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0_13,axiom,
    ! [VarCurr] :
      ( v9042(VarCurr)
     => ( ( v9056(VarCurr,bitIndex69)
        <=> v3066(VarCurr,bitIndex419) )
        & ( v9056(VarCurr,bitIndex68)
        <=> v3066(VarCurr,bitIndex418) )
        & ( v9056(VarCurr,bitIndex67)
        <=> v3066(VarCurr,bitIndex417) )
        & ( v9056(VarCurr,bitIndex66)
        <=> v3066(VarCurr,bitIndex416) )
        & ( v9056(VarCurr,bitIndex65)
        <=> v3066(VarCurr,bitIndex415) )
        & ( v9056(VarCurr,bitIndex64)
        <=> v3066(VarCurr,bitIndex414) )
        & ( v9056(VarCurr,bitIndex63)
        <=> v3066(VarCurr,bitIndex413) )
        & ( v9056(VarCurr,bitIndex62)
        <=> v3066(VarCurr,bitIndex412) )
        & ( v9056(VarCurr,bitIndex61)
        <=> v3066(VarCurr,bitIndex411) )
        & ( v9056(VarCurr,bitIndex60)
        <=> v3066(VarCurr,bitIndex410) )
        & ( v9056(VarCurr,bitIndex59)
        <=> v3066(VarCurr,bitIndex409) )
        & ( v9056(VarCurr,bitIndex58)
        <=> v3066(VarCurr,bitIndex408) )
        & ( v9056(VarCurr,bitIndex57)
        <=> v3066(VarCurr,bitIndex407) )
        & ( v9056(VarCurr,bitIndex56)
        <=> v3066(VarCurr,bitIndex406) )
        & ( v9056(VarCurr,bitIndex55)
        <=> v3066(VarCurr,bitIndex405) )
        & ( v9056(VarCurr,bitIndex54)
        <=> v3066(VarCurr,bitIndex404) )
        & ( v9056(VarCurr,bitIndex53)
        <=> v3066(VarCurr,bitIndex403) )
        & ( v9056(VarCurr,bitIndex52)
        <=> v3066(VarCurr,bitIndex402) )
        & ( v9056(VarCurr,bitIndex51)
        <=> v3066(VarCurr,bitIndex401) )
        & ( v9056(VarCurr,bitIndex50)
        <=> v3066(VarCurr,bitIndex400) )
        & ( v9056(VarCurr,bitIndex49)
        <=> v3066(VarCurr,bitIndex399) )
        & ( v9056(VarCurr,bitIndex48)
        <=> v3066(VarCurr,bitIndex398) )
        & ( v9056(VarCurr,bitIndex47)
        <=> v3066(VarCurr,bitIndex397) )
        & ( v9056(VarCurr,bitIndex46)
        <=> v3066(VarCurr,bitIndex396) )
        & ( v9056(VarCurr,bitIndex45)
        <=> v3066(VarCurr,bitIndex395) )
        & ( v9056(VarCurr,bitIndex44)
        <=> v3066(VarCurr,bitIndex394) )
        & ( v9056(VarCurr,bitIndex43)
        <=> v3066(VarCurr,bitIndex393) )
        & ( v9056(VarCurr,bitIndex42)
        <=> v3066(VarCurr,bitIndex392) )
        & ( v9056(VarCurr,bitIndex41)
        <=> v3066(VarCurr,bitIndex391) )
        & ( v9056(VarCurr,bitIndex40)
        <=> v3066(VarCurr,bitIndex390) )
        & ( v9056(VarCurr,bitIndex39)
        <=> v3066(VarCurr,bitIndex389) )
        & ( v9056(VarCurr,bitIndex38)
        <=> v3066(VarCurr,bitIndex388) )
        & ( v9056(VarCurr,bitIndex37)
        <=> v3066(VarCurr,bitIndex387) )
        & ( v9056(VarCurr,bitIndex36)
        <=> v3066(VarCurr,bitIndex386) )
        & ( v9056(VarCurr,bitIndex35)
        <=> v3066(VarCurr,bitIndex385) )
        & ( v9056(VarCurr,bitIndex34)
        <=> v3066(VarCurr,bitIndex384) )
        & ( v9056(VarCurr,bitIndex33)
        <=> v3066(VarCurr,bitIndex383) )
        & ( v9056(VarCurr,bitIndex32)
        <=> v3066(VarCurr,bitIndex382) )
        & ( v9056(VarCurr,bitIndex31)
        <=> v3066(VarCurr,bitIndex381) )
        & ( v9056(VarCurr,bitIndex30)
        <=> v3066(VarCurr,bitIndex380) )
        & ( v9056(VarCurr,bitIndex29)
        <=> v3066(VarCurr,bitIndex379) )
        & ( v9056(VarCurr,bitIndex28)
        <=> v3066(VarCurr,bitIndex378) )
        & ( v9056(VarCurr,bitIndex27)
        <=> v3066(VarCurr,bitIndex377) )
        & ( v9056(VarCurr,bitIndex26)
        <=> v3066(VarCurr,bitIndex376) )
        & ( v9056(VarCurr,bitIndex25)
        <=> v3066(VarCurr,bitIndex375) )
        & ( v9056(VarCurr,bitIndex24)
        <=> v3066(VarCurr,bitIndex374) )
        & ( v9056(VarCurr,bitIndex23)
        <=> v3066(VarCurr,bitIndex373) )
        & ( v9056(VarCurr,bitIndex22)
        <=> v3066(VarCurr,bitIndex372) )
        & ( v9056(VarCurr,bitIndex21)
        <=> v3066(VarCurr,bitIndex371) )
        & ( v9056(VarCurr,bitIndex20)
        <=> v3066(VarCurr,bitIndex370) )
        & ( v9056(VarCurr,bitIndex19)
        <=> v3066(VarCurr,bitIndex369) )
        & ( v9056(VarCurr,bitIndex18)
        <=> v3066(VarCurr,bitIndex368) )
        & ( v9056(VarCurr,bitIndex17)
        <=> v3066(VarCurr,bitIndex367) )
        & ( v9056(VarCurr,bitIndex16)
        <=> v3066(VarCurr,bitIndex366) )
        & ( v9056(VarCurr,bitIndex15)
        <=> v3066(VarCurr,bitIndex365) )
        & ( v9056(VarCurr,bitIndex14)
        <=> v3066(VarCurr,bitIndex364) )
        & ( v9056(VarCurr,bitIndex13)
        <=> v3066(VarCurr,bitIndex363) )
        & ( v9056(VarCurr,bitIndex12)
        <=> v3066(VarCurr,bitIndex362) )
        & ( v9056(VarCurr,bitIndex11)
        <=> v3066(VarCurr,bitIndex361) )
        & ( v9056(VarCurr,bitIndex10)
        <=> v3066(VarCurr,bitIndex360) )
        & ( v9056(VarCurr,bitIndex9)
        <=> v3066(VarCurr,bitIndex359) )
        & ( v9056(VarCurr,bitIndex8)
        <=> v3066(VarCurr,bitIndex358) )
        & ( v9056(VarCurr,bitIndex7)
        <=> v3066(VarCurr,bitIndex357) )
        & ( v9056(VarCurr,bitIndex6)
        <=> v3066(VarCurr,bitIndex356) )
        & ( v9056(VarCurr,bitIndex5)
        <=> v3066(VarCurr,bitIndex355) )
        & ( v9056(VarCurr,bitIndex4)
        <=> v3066(VarCurr,bitIndex354) )
        & ( v9056(VarCurr,bitIndex3)
        <=> v3066(VarCurr,bitIndex353) )
        & ( v9056(VarCurr,bitIndex2)
        <=> v3066(VarCurr,bitIndex352) )
        & ( v9056(VarCurr,bitIndex1)
        <=> v3066(VarCurr,bitIndex351) )
        & ( v9056(VarCurr,bitIndex0)
        <=> v3066(VarCurr,bitIndex350) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1697,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9029(VarNext)
      <=> ( v9030(VarNext)
          & v9037(VarNext) ) ) ) ).

fof(addAssignment_2093,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9037(VarNext)
      <=> v9035(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1696,axiom,
    ! [VarCurr] :
      ( v9035(VarCurr)
    <=> ( v9038(VarCurr)
        & v9049(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1695,axiom,
    ! [VarCurr] :
      ( v9049(VarCurr)
    <=> ( v9050(VarCurr)
        | v8900(VarCurr) ) ) ).

fof(writeUnaryOperator_792,axiom,
    ! [VarCurr] :
      ( ~ v9050(VarCurr)
    <=> v9051(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_640,axiom,
    ! [VarCurr] :
      ( v9051(VarCurr)
    <=> ( ( v9052(VarCurr,bitIndex1)
        <=> $false )
        & ( v9052(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2092,axiom,
    ! [VarCurr] :
      ( v9052(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2091,axiom,
    ! [VarCurr] :
      ( v9052(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1694,axiom,
    ! [VarCurr] :
      ( v9038(VarCurr)
    <=> ( v8900(VarCurr)
        | v9039(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1693,axiom,
    ! [VarCurr] :
      ( v9039(VarCurr)
    <=> ( v9040(VarCurr)
        & v9048(VarCurr) ) ) ).

fof(writeUnaryOperator_791,axiom,
    ! [VarCurr] :
      ( ~ v9048(VarCurr)
    <=> v8900(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1692,axiom,
    ! [VarCurr] :
      ( v9040(VarCurr)
    <=> ( v9041(VarCurr)
        | v9046(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_639,axiom,
    ! [VarCurr] :
      ( v9046(VarCurr)
    <=> ( ( v9047(VarCurr,bitIndex1)
        <=> $true )
        & ( v9047(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2090,axiom,
    ! [VarCurr] :
      ( v9047(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2089,axiom,
    ! [VarCurr] :
      ( v9047(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1691,axiom,
    ! [VarCurr] :
      ( v9041(VarCurr)
    <=> ( v9042(VarCurr)
        | v9044(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_638,axiom,
    ! [VarCurr] :
      ( v9044(VarCurr)
    <=> ( ( v9045(VarCurr,bitIndex1)
        <=> $true )
        & ( v9045(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2088,axiom,
    ! [VarCurr] :
      ( v9045(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2087,axiom,
    ! [VarCurr] :
      ( v9045(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_637,axiom,
    ! [VarCurr] :
      ( v9042(VarCurr)
    <=> ( ( v9043(VarCurr,bitIndex1)
        <=> $false )
        & ( v9043(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2086,axiom,
    ! [VarCurr] :
      ( v9043(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2085,axiom,
    ! [VarCurr] :
      ( v9043(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1690,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v9030(VarNext)
      <=> ( v9032(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_790,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v9032(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2084,axiom,
    ! [VarCurr] :
      ( v9021(VarCurr,bitIndex49)
    <=> v9026(VarCurr,bitIndex49) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_219,axiom,
    ! [VarCurr] :
      ( ~ v9023(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9026(VarCurr,B)
          <=> v9025(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_222,axiom,
    ! [VarCurr] :
      ( v9023(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9026(VarCurr,B)
          <=> v3163(VarCurr,B) ) ) ) ).

fof(addAssignment_2083,axiom,
    ! [VarCurr] :
      ( v9025(VarCurr,bitIndex49)
    <=> v3066(VarCurr,bitIndex399) ) ).

fof(addAssignment_2082,axiom,
    ! [VarCurr] :
      ( v9023(VarCurr)
    <=> v3073(VarCurr,bitIndex2) ) ).

fof(addAssignment_2081,axiom,
    ! [VarCurr] :
      ( v9014(VarCurr,bitIndex49)
    <=> v9019(VarCurr,bitIndex49) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_218,axiom,
    ! [VarCurr] :
      ( ~ v9016(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9019(VarCurr,B)
          <=> v9018(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_221,axiom,
    ! [VarCurr] :
      ( v9016(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9019(VarCurr,B)
          <=> v3163(VarCurr,B) ) ) ) ).

fof(addAssignment_2080,axiom,
    ! [VarCurr] :
      ( v9018(VarCurr,bitIndex49)
    <=> v3066(VarCurr,bitIndex469) ) ).

fof(addAssignment_2079,axiom,
    ! [VarCurr] :
      ( v9016(VarCurr)
    <=> v3073(VarCurr,bitIndex2) ) ).

fof(addAssignment_2078,axiom,
    ! [VarNext] :
      ( v3066(VarNext,bitIndex399)
    <=> v8982(VarNext,bitIndex49) ) ).

fof(addCaseBooleanConditionShiftedRanges1_20,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8983(VarNext)
       => ( ( v8982(VarNext,bitIndex69)
          <=> v3066(VarCurr,bitIndex419) )
          & ( v8982(VarNext,bitIndex68)
          <=> v3066(VarCurr,bitIndex418) )
          & ( v8982(VarNext,bitIndex67)
          <=> v3066(VarCurr,bitIndex417) )
          & ( v8982(VarNext,bitIndex66)
          <=> v3066(VarCurr,bitIndex416) )
          & ( v8982(VarNext,bitIndex65)
          <=> v3066(VarCurr,bitIndex415) )
          & ( v8982(VarNext,bitIndex64)
          <=> v3066(VarCurr,bitIndex414) )
          & ( v8982(VarNext,bitIndex63)
          <=> v3066(VarCurr,bitIndex413) )
          & ( v8982(VarNext,bitIndex62)
          <=> v3066(VarCurr,bitIndex412) )
          & ( v8982(VarNext,bitIndex61)
          <=> v3066(VarCurr,bitIndex411) )
          & ( v8982(VarNext,bitIndex60)
          <=> v3066(VarCurr,bitIndex410) )
          & ( v8982(VarNext,bitIndex59)
          <=> v3066(VarCurr,bitIndex409) )
          & ( v8982(VarNext,bitIndex58)
          <=> v3066(VarCurr,bitIndex408) )
          & ( v8982(VarNext,bitIndex57)
          <=> v3066(VarCurr,bitIndex407) )
          & ( v8982(VarNext,bitIndex56)
          <=> v3066(VarCurr,bitIndex406) )
          & ( v8982(VarNext,bitIndex55)
          <=> v3066(VarCurr,bitIndex405) )
          & ( v8982(VarNext,bitIndex54)
          <=> v3066(VarCurr,bitIndex404) )
          & ( v8982(VarNext,bitIndex53)
          <=> v3066(VarCurr,bitIndex403) )
          & ( v8982(VarNext,bitIndex52)
          <=> v3066(VarCurr,bitIndex402) )
          & ( v8982(VarNext,bitIndex51)
          <=> v3066(VarCurr,bitIndex401) )
          & ( v8982(VarNext,bitIndex50)
          <=> v3066(VarCurr,bitIndex400) )
          & ( v8982(VarNext,bitIndex49)
          <=> v3066(VarCurr,bitIndex399) )
          & ( v8982(VarNext,bitIndex48)
          <=> v3066(VarCurr,bitIndex398) )
          & ( v8982(VarNext,bitIndex47)
          <=> v3066(VarCurr,bitIndex397) )
          & ( v8982(VarNext,bitIndex46)
          <=> v3066(VarCurr,bitIndex396) )
          & ( v8982(VarNext,bitIndex45)
          <=> v3066(VarCurr,bitIndex395) )
          & ( v8982(VarNext,bitIndex44)
          <=> v3066(VarCurr,bitIndex394) )
          & ( v8982(VarNext,bitIndex43)
          <=> v3066(VarCurr,bitIndex393) )
          & ( v8982(VarNext,bitIndex42)
          <=> v3066(VarCurr,bitIndex392) )
          & ( v8982(VarNext,bitIndex41)
          <=> v3066(VarCurr,bitIndex391) )
          & ( v8982(VarNext,bitIndex40)
          <=> v3066(VarCurr,bitIndex390) )
          & ( v8982(VarNext,bitIndex39)
          <=> v3066(VarCurr,bitIndex389) )
          & ( v8982(VarNext,bitIndex38)
          <=> v3066(VarCurr,bitIndex388) )
          & ( v8982(VarNext,bitIndex37)
          <=> v3066(VarCurr,bitIndex387) )
          & ( v8982(VarNext,bitIndex36)
          <=> v3066(VarCurr,bitIndex386) )
          & ( v8982(VarNext,bitIndex35)
          <=> v3066(VarCurr,bitIndex385) )
          & ( v8982(VarNext,bitIndex34)
          <=> v3066(VarCurr,bitIndex384) )
          & ( v8982(VarNext,bitIndex33)
          <=> v3066(VarCurr,bitIndex383) )
          & ( v8982(VarNext,bitIndex32)
          <=> v3066(VarCurr,bitIndex382) )
          & ( v8982(VarNext,bitIndex31)
          <=> v3066(VarCurr,bitIndex381) )
          & ( v8982(VarNext,bitIndex30)
          <=> v3066(VarCurr,bitIndex380) )
          & ( v8982(VarNext,bitIndex29)
          <=> v3066(VarCurr,bitIndex379) )
          & ( v8982(VarNext,bitIndex28)
          <=> v3066(VarCurr,bitIndex378) )
          & ( v8982(VarNext,bitIndex27)
          <=> v3066(VarCurr,bitIndex377) )
          & ( v8982(VarNext,bitIndex26)
          <=> v3066(VarCurr,bitIndex376) )
          & ( v8982(VarNext,bitIndex25)
          <=> v3066(VarCurr,bitIndex375) )
          & ( v8982(VarNext,bitIndex24)
          <=> v3066(VarCurr,bitIndex374) )
          & ( v8982(VarNext,bitIndex23)
          <=> v3066(VarCurr,bitIndex373) )
          & ( v8982(VarNext,bitIndex22)
          <=> v3066(VarCurr,bitIndex372) )
          & ( v8982(VarNext,bitIndex21)
          <=> v3066(VarCurr,bitIndex371) )
          & ( v8982(VarNext,bitIndex20)
          <=> v3066(VarCurr,bitIndex370) )
          & ( v8982(VarNext,bitIndex19)
          <=> v3066(VarCurr,bitIndex369) )
          & ( v8982(VarNext,bitIndex18)
          <=> v3066(VarCurr,bitIndex368) )
          & ( v8982(VarNext,bitIndex17)
          <=> v3066(VarCurr,bitIndex367) )
          & ( v8982(VarNext,bitIndex16)
          <=> v3066(VarCurr,bitIndex366) )
          & ( v8982(VarNext,bitIndex15)
          <=> v3066(VarCurr,bitIndex365) )
          & ( v8982(VarNext,bitIndex14)
          <=> v3066(VarCurr,bitIndex364) )
          & ( v8982(VarNext,bitIndex13)
          <=> v3066(VarCurr,bitIndex363) )
          & ( v8982(VarNext,bitIndex12)
          <=> v3066(VarCurr,bitIndex362) )
          & ( v8982(VarNext,bitIndex11)
          <=> v3066(VarCurr,bitIndex361) )
          & ( v8982(VarNext,bitIndex10)
          <=> v3066(VarCurr,bitIndex360) )
          & ( v8982(VarNext,bitIndex9)
          <=> v3066(VarCurr,bitIndex359) )
          & ( v8982(VarNext,bitIndex8)
          <=> v3066(VarCurr,bitIndex358) )
          & ( v8982(VarNext,bitIndex7)
          <=> v3066(VarCurr,bitIndex357) )
          & ( v8982(VarNext,bitIndex6)
          <=> v3066(VarCurr,bitIndex356) )
          & ( v8982(VarNext,bitIndex5)
          <=> v3066(VarCurr,bitIndex355) )
          & ( v8982(VarNext,bitIndex4)
          <=> v3066(VarCurr,bitIndex354) )
          & ( v8982(VarNext,bitIndex3)
          <=> v3066(VarCurr,bitIndex353) )
          & ( v8982(VarNext,bitIndex2)
          <=> v3066(VarCurr,bitIndex352) )
          & ( v8982(VarNext,bitIndex1)
          <=> v3066(VarCurr,bitIndex351) )
          & ( v8982(VarNext,bitIndex0)
          <=> v3066(VarCurr,bitIndex350) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_154,axiom,
    ! [VarNext] :
      ( v8983(VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v8982(VarNext,B)
          <=> v9009(VarNext,B) ) ) ) ).

fof(addAssignment_2077,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v9009(VarNext,B)
          <=> v9007(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_218,axiom,
    ! [VarCurr] :
      ( ~ v8900(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9007(VarCurr,B)
          <=> v9010(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_207,axiom,
    ! [VarCurr] :
      ( v8900(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9007(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_83,axiom,
    ! [VarCurr] :
      ( ( ~ v8996(VarCurr)
        & ~ v8998(VarCurr) )
     => ! [B] :
          ( range_69_0(B)
         => ( v9010(VarCurr,B)
          <=> v8975(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_217,axiom,
    ! [VarCurr] :
      ( v8998(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v9010(VarCurr,B)
          <=> v8968(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0_12,axiom,
    ! [VarCurr] :
      ( v8996(VarCurr)
     => ( ( v9010(VarCurr,bitIndex69)
        <=> v3066(VarCurr,bitIndex349) )
        & ( v9010(VarCurr,bitIndex68)
        <=> v3066(VarCurr,bitIndex348) )
        & ( v9010(VarCurr,bitIndex67)
        <=> v3066(VarCurr,bitIndex347) )
        & ( v9010(VarCurr,bitIndex66)
        <=> v3066(VarCurr,bitIndex346) )
        & ( v9010(VarCurr,bitIndex65)
        <=> v3066(VarCurr,bitIndex345) )
        & ( v9010(VarCurr,bitIndex64)
        <=> v3066(VarCurr,bitIndex344) )
        & ( v9010(VarCurr,bitIndex63)
        <=> v3066(VarCurr,bitIndex343) )
        & ( v9010(VarCurr,bitIndex62)
        <=> v3066(VarCurr,bitIndex342) )
        & ( v9010(VarCurr,bitIndex61)
        <=> v3066(VarCurr,bitIndex341) )
        & ( v9010(VarCurr,bitIndex60)
        <=> v3066(VarCurr,bitIndex340) )
        & ( v9010(VarCurr,bitIndex59)
        <=> v3066(VarCurr,bitIndex339) )
        & ( v9010(VarCurr,bitIndex58)
        <=> v3066(VarCurr,bitIndex338) )
        & ( v9010(VarCurr,bitIndex57)
        <=> v3066(VarCurr,bitIndex337) )
        & ( v9010(VarCurr,bitIndex56)
        <=> v3066(VarCurr,bitIndex336) )
        & ( v9010(VarCurr,bitIndex55)
        <=> v3066(VarCurr,bitIndex335) )
        & ( v9010(VarCurr,bitIndex54)
        <=> v3066(VarCurr,bitIndex334) )
        & ( v9010(VarCurr,bitIndex53)
        <=> v3066(VarCurr,bitIndex333) )
        & ( v9010(VarCurr,bitIndex52)
        <=> v3066(VarCurr,bitIndex332) )
        & ( v9010(VarCurr,bitIndex51)
        <=> v3066(VarCurr,bitIndex331) )
        & ( v9010(VarCurr,bitIndex50)
        <=> v3066(VarCurr,bitIndex330) )
        & ( v9010(VarCurr,bitIndex49)
        <=> v3066(VarCurr,bitIndex329) )
        & ( v9010(VarCurr,bitIndex48)
        <=> v3066(VarCurr,bitIndex328) )
        & ( v9010(VarCurr,bitIndex47)
        <=> v3066(VarCurr,bitIndex327) )
        & ( v9010(VarCurr,bitIndex46)
        <=> v3066(VarCurr,bitIndex326) )
        & ( v9010(VarCurr,bitIndex45)
        <=> v3066(VarCurr,bitIndex325) )
        & ( v9010(VarCurr,bitIndex44)
        <=> v3066(VarCurr,bitIndex324) )
        & ( v9010(VarCurr,bitIndex43)
        <=> v3066(VarCurr,bitIndex323) )
        & ( v9010(VarCurr,bitIndex42)
        <=> v3066(VarCurr,bitIndex322) )
        & ( v9010(VarCurr,bitIndex41)
        <=> v3066(VarCurr,bitIndex321) )
        & ( v9010(VarCurr,bitIndex40)
        <=> v3066(VarCurr,bitIndex320) )
        & ( v9010(VarCurr,bitIndex39)
        <=> v3066(VarCurr,bitIndex319) )
        & ( v9010(VarCurr,bitIndex38)
        <=> v3066(VarCurr,bitIndex318) )
        & ( v9010(VarCurr,bitIndex37)
        <=> v3066(VarCurr,bitIndex317) )
        & ( v9010(VarCurr,bitIndex36)
        <=> v3066(VarCurr,bitIndex316) )
        & ( v9010(VarCurr,bitIndex35)
        <=> v3066(VarCurr,bitIndex315) )
        & ( v9010(VarCurr,bitIndex34)
        <=> v3066(VarCurr,bitIndex314) )
        & ( v9010(VarCurr,bitIndex33)
        <=> v3066(VarCurr,bitIndex313) )
        & ( v9010(VarCurr,bitIndex32)
        <=> v3066(VarCurr,bitIndex312) )
        & ( v9010(VarCurr,bitIndex31)
        <=> v3066(VarCurr,bitIndex311) )
        & ( v9010(VarCurr,bitIndex30)
        <=> v3066(VarCurr,bitIndex310) )
        & ( v9010(VarCurr,bitIndex29)
        <=> v3066(VarCurr,bitIndex309) )
        & ( v9010(VarCurr,bitIndex28)
        <=> v3066(VarCurr,bitIndex308) )
        & ( v9010(VarCurr,bitIndex27)
        <=> v3066(VarCurr,bitIndex307) )
        & ( v9010(VarCurr,bitIndex26)
        <=> v3066(VarCurr,bitIndex306) )
        & ( v9010(VarCurr,bitIndex25)
        <=> v3066(VarCurr,bitIndex305) )
        & ( v9010(VarCurr,bitIndex24)
        <=> v3066(VarCurr,bitIndex304) )
        & ( v9010(VarCurr,bitIndex23)
        <=> v3066(VarCurr,bitIndex303) )
        & ( v9010(VarCurr,bitIndex22)
        <=> v3066(VarCurr,bitIndex302) )
        & ( v9010(VarCurr,bitIndex21)
        <=> v3066(VarCurr,bitIndex301) )
        & ( v9010(VarCurr,bitIndex20)
        <=> v3066(VarCurr,bitIndex300) )
        & ( v9010(VarCurr,bitIndex19)
        <=> v3066(VarCurr,bitIndex299) )
        & ( v9010(VarCurr,bitIndex18)
        <=> v3066(VarCurr,bitIndex298) )
        & ( v9010(VarCurr,bitIndex17)
        <=> v3066(VarCurr,bitIndex297) )
        & ( v9010(VarCurr,bitIndex16)
        <=> v3066(VarCurr,bitIndex296) )
        & ( v9010(VarCurr,bitIndex15)
        <=> v3066(VarCurr,bitIndex295) )
        & ( v9010(VarCurr,bitIndex14)
        <=> v3066(VarCurr,bitIndex294) )
        & ( v9010(VarCurr,bitIndex13)
        <=> v3066(VarCurr,bitIndex293) )
        & ( v9010(VarCurr,bitIndex12)
        <=> v3066(VarCurr,bitIndex292) )
        & ( v9010(VarCurr,bitIndex11)
        <=> v3066(VarCurr,bitIndex291) )
        & ( v9010(VarCurr,bitIndex10)
        <=> v3066(VarCurr,bitIndex290) )
        & ( v9010(VarCurr,bitIndex9)
        <=> v3066(VarCurr,bitIndex289) )
        & ( v9010(VarCurr,bitIndex8)
        <=> v3066(VarCurr,bitIndex288) )
        & ( v9010(VarCurr,bitIndex7)
        <=> v3066(VarCurr,bitIndex287) )
        & ( v9010(VarCurr,bitIndex6)
        <=> v3066(VarCurr,bitIndex286) )
        & ( v9010(VarCurr,bitIndex5)
        <=> v3066(VarCurr,bitIndex285) )
        & ( v9010(VarCurr,bitIndex4)
        <=> v3066(VarCurr,bitIndex284) )
        & ( v9010(VarCurr,bitIndex3)
        <=> v3066(VarCurr,bitIndex283) )
        & ( v9010(VarCurr,bitIndex2)
        <=> v3066(VarCurr,bitIndex282) )
        & ( v9010(VarCurr,bitIndex1)
        <=> v3066(VarCurr,bitIndex281) )
        & ( v9010(VarCurr,bitIndex0)
        <=> v3066(VarCurr,bitIndex280) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1689,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8983(VarNext)
      <=> ( v8984(VarNext)
          & v8991(VarNext) ) ) ) ).

fof(addAssignment_2076,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8991(VarNext)
      <=> v8989(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1688,axiom,
    ! [VarCurr] :
      ( v8989(VarCurr)
    <=> ( v8992(VarCurr)
        & v9003(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1687,axiom,
    ! [VarCurr] :
      ( v9003(VarCurr)
    <=> ( v9004(VarCurr)
        | v8900(VarCurr) ) ) ).

fof(writeUnaryOperator_789,axiom,
    ! [VarCurr] :
      ( ~ v9004(VarCurr)
    <=> v9005(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_636,axiom,
    ! [VarCurr] :
      ( v9005(VarCurr)
    <=> ( ( v9006(VarCurr,bitIndex1)
        <=> $false )
        & ( v9006(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2075,axiom,
    ! [VarCurr] :
      ( v9006(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2074,axiom,
    ! [VarCurr] :
      ( v9006(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1686,axiom,
    ! [VarCurr] :
      ( v8992(VarCurr)
    <=> ( v8900(VarCurr)
        | v8993(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1685,axiom,
    ! [VarCurr] :
      ( v8993(VarCurr)
    <=> ( v8994(VarCurr)
        & v9002(VarCurr) ) ) ).

fof(writeUnaryOperator_788,axiom,
    ! [VarCurr] :
      ( ~ v9002(VarCurr)
    <=> v8900(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1684,axiom,
    ! [VarCurr] :
      ( v8994(VarCurr)
    <=> ( v8995(VarCurr)
        | v9000(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_635,axiom,
    ! [VarCurr] :
      ( v9000(VarCurr)
    <=> ( ( v9001(VarCurr,bitIndex1)
        <=> $true )
        & ( v9001(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2073,axiom,
    ! [VarCurr] :
      ( v9001(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2072,axiom,
    ! [VarCurr] :
      ( v9001(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1683,axiom,
    ! [VarCurr] :
      ( v8995(VarCurr)
    <=> ( v8996(VarCurr)
        | v8998(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_634,axiom,
    ! [VarCurr] :
      ( v8998(VarCurr)
    <=> ( ( v8999(VarCurr,bitIndex1)
        <=> $true )
        & ( v8999(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2071,axiom,
    ! [VarCurr] :
      ( v8999(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2070,axiom,
    ! [VarCurr] :
      ( v8999(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_633,axiom,
    ! [VarCurr] :
      ( v8996(VarCurr)
    <=> ( ( v8997(VarCurr,bitIndex1)
        <=> $false )
        & ( v8997(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2069,axiom,
    ! [VarCurr] :
      ( v8997(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2068,axiom,
    ! [VarCurr] :
      ( v8997(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1682,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8984(VarNext)
      <=> ( v8986(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_787,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8986(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2067,axiom,
    ! [VarCurr] :
      ( v8975(VarCurr,bitIndex49)
    <=> v8980(VarCurr,bitIndex49) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_217,axiom,
    ! [VarCurr] :
      ( ~ v8977(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8980(VarCurr,B)
          <=> v8979(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_220,axiom,
    ! [VarCurr] :
      ( v8977(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8980(VarCurr,B)
          <=> v3163(VarCurr,B) ) ) ) ).

fof(addAssignment_2066,axiom,
    ! [VarCurr] :
      ( v8979(VarCurr,bitIndex49)
    <=> v3066(VarCurr,bitIndex329) ) ).

fof(addAssignment_2065,axiom,
    ! [VarCurr] :
      ( v8977(VarCurr)
    <=> v3073(VarCurr,bitIndex3) ) ).

fof(addAssignment_2064,axiom,
    ! [VarCurr] :
      ( v8968(VarCurr,bitIndex49)
    <=> v8973(VarCurr,bitIndex49) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_216,axiom,
    ! [VarCurr] :
      ( ~ v8970(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8973(VarCurr,B)
          <=> v8972(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_219,axiom,
    ! [VarCurr] :
      ( v8970(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8973(VarCurr,B)
          <=> v3163(VarCurr,B) ) ) ) ).

fof(addAssignment_2063,axiom,
    ! [VarCurr] :
      ( v8972(VarCurr,bitIndex49)
    <=> v3066(VarCurr,bitIndex399) ) ).

fof(addAssignment_2062,axiom,
    ! [VarCurr] :
      ( v8970(VarCurr)
    <=> v3073(VarCurr,bitIndex3) ) ).

fof(addAssignment_2061,axiom,
    ! [VarNext] :
      ( v3066(VarNext,bitIndex329)
    <=> v8936(VarNext,bitIndex49) ) ).

fof(addCaseBooleanConditionShiftedRanges1_19,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8937(VarNext)
       => ( ( v8936(VarNext,bitIndex69)
          <=> v3066(VarCurr,bitIndex349) )
          & ( v8936(VarNext,bitIndex68)
          <=> v3066(VarCurr,bitIndex348) )
          & ( v8936(VarNext,bitIndex67)
          <=> v3066(VarCurr,bitIndex347) )
          & ( v8936(VarNext,bitIndex66)
          <=> v3066(VarCurr,bitIndex346) )
          & ( v8936(VarNext,bitIndex65)
          <=> v3066(VarCurr,bitIndex345) )
          & ( v8936(VarNext,bitIndex64)
          <=> v3066(VarCurr,bitIndex344) )
          & ( v8936(VarNext,bitIndex63)
          <=> v3066(VarCurr,bitIndex343) )
          & ( v8936(VarNext,bitIndex62)
          <=> v3066(VarCurr,bitIndex342) )
          & ( v8936(VarNext,bitIndex61)
          <=> v3066(VarCurr,bitIndex341) )
          & ( v8936(VarNext,bitIndex60)
          <=> v3066(VarCurr,bitIndex340) )
          & ( v8936(VarNext,bitIndex59)
          <=> v3066(VarCurr,bitIndex339) )
          & ( v8936(VarNext,bitIndex58)
          <=> v3066(VarCurr,bitIndex338) )
          & ( v8936(VarNext,bitIndex57)
          <=> v3066(VarCurr,bitIndex337) )
          & ( v8936(VarNext,bitIndex56)
          <=> v3066(VarCurr,bitIndex336) )
          & ( v8936(VarNext,bitIndex55)
          <=> v3066(VarCurr,bitIndex335) )
          & ( v8936(VarNext,bitIndex54)
          <=> v3066(VarCurr,bitIndex334) )
          & ( v8936(VarNext,bitIndex53)
          <=> v3066(VarCurr,bitIndex333) )
          & ( v8936(VarNext,bitIndex52)
          <=> v3066(VarCurr,bitIndex332) )
          & ( v8936(VarNext,bitIndex51)
          <=> v3066(VarCurr,bitIndex331) )
          & ( v8936(VarNext,bitIndex50)
          <=> v3066(VarCurr,bitIndex330) )
          & ( v8936(VarNext,bitIndex49)
          <=> v3066(VarCurr,bitIndex329) )
          & ( v8936(VarNext,bitIndex48)
          <=> v3066(VarCurr,bitIndex328) )
          & ( v8936(VarNext,bitIndex47)
          <=> v3066(VarCurr,bitIndex327) )
          & ( v8936(VarNext,bitIndex46)
          <=> v3066(VarCurr,bitIndex326) )
          & ( v8936(VarNext,bitIndex45)
          <=> v3066(VarCurr,bitIndex325) )
          & ( v8936(VarNext,bitIndex44)
          <=> v3066(VarCurr,bitIndex324) )
          & ( v8936(VarNext,bitIndex43)
          <=> v3066(VarCurr,bitIndex323) )
          & ( v8936(VarNext,bitIndex42)
          <=> v3066(VarCurr,bitIndex322) )
          & ( v8936(VarNext,bitIndex41)
          <=> v3066(VarCurr,bitIndex321) )
          & ( v8936(VarNext,bitIndex40)
          <=> v3066(VarCurr,bitIndex320) )
          & ( v8936(VarNext,bitIndex39)
          <=> v3066(VarCurr,bitIndex319) )
          & ( v8936(VarNext,bitIndex38)
          <=> v3066(VarCurr,bitIndex318) )
          & ( v8936(VarNext,bitIndex37)
          <=> v3066(VarCurr,bitIndex317) )
          & ( v8936(VarNext,bitIndex36)
          <=> v3066(VarCurr,bitIndex316) )
          & ( v8936(VarNext,bitIndex35)
          <=> v3066(VarCurr,bitIndex315) )
          & ( v8936(VarNext,bitIndex34)
          <=> v3066(VarCurr,bitIndex314) )
          & ( v8936(VarNext,bitIndex33)
          <=> v3066(VarCurr,bitIndex313) )
          & ( v8936(VarNext,bitIndex32)
          <=> v3066(VarCurr,bitIndex312) )
          & ( v8936(VarNext,bitIndex31)
          <=> v3066(VarCurr,bitIndex311) )
          & ( v8936(VarNext,bitIndex30)
          <=> v3066(VarCurr,bitIndex310) )
          & ( v8936(VarNext,bitIndex29)
          <=> v3066(VarCurr,bitIndex309) )
          & ( v8936(VarNext,bitIndex28)
          <=> v3066(VarCurr,bitIndex308) )
          & ( v8936(VarNext,bitIndex27)
          <=> v3066(VarCurr,bitIndex307) )
          & ( v8936(VarNext,bitIndex26)
          <=> v3066(VarCurr,bitIndex306) )
          & ( v8936(VarNext,bitIndex25)
          <=> v3066(VarCurr,bitIndex305) )
          & ( v8936(VarNext,bitIndex24)
          <=> v3066(VarCurr,bitIndex304) )
          & ( v8936(VarNext,bitIndex23)
          <=> v3066(VarCurr,bitIndex303) )
          & ( v8936(VarNext,bitIndex22)
          <=> v3066(VarCurr,bitIndex302) )
          & ( v8936(VarNext,bitIndex21)
          <=> v3066(VarCurr,bitIndex301) )
          & ( v8936(VarNext,bitIndex20)
          <=> v3066(VarCurr,bitIndex300) )
          & ( v8936(VarNext,bitIndex19)
          <=> v3066(VarCurr,bitIndex299) )
          & ( v8936(VarNext,bitIndex18)
          <=> v3066(VarCurr,bitIndex298) )
          & ( v8936(VarNext,bitIndex17)
          <=> v3066(VarCurr,bitIndex297) )
          & ( v8936(VarNext,bitIndex16)
          <=> v3066(VarCurr,bitIndex296) )
          & ( v8936(VarNext,bitIndex15)
          <=> v3066(VarCurr,bitIndex295) )
          & ( v8936(VarNext,bitIndex14)
          <=> v3066(VarCurr,bitIndex294) )
          & ( v8936(VarNext,bitIndex13)
          <=> v3066(VarCurr,bitIndex293) )
          & ( v8936(VarNext,bitIndex12)
          <=> v3066(VarCurr,bitIndex292) )
          & ( v8936(VarNext,bitIndex11)
          <=> v3066(VarCurr,bitIndex291) )
          & ( v8936(VarNext,bitIndex10)
          <=> v3066(VarCurr,bitIndex290) )
          & ( v8936(VarNext,bitIndex9)
          <=> v3066(VarCurr,bitIndex289) )
          & ( v8936(VarNext,bitIndex8)
          <=> v3066(VarCurr,bitIndex288) )
          & ( v8936(VarNext,bitIndex7)
          <=> v3066(VarCurr,bitIndex287) )
          & ( v8936(VarNext,bitIndex6)
          <=> v3066(VarCurr,bitIndex286) )
          & ( v8936(VarNext,bitIndex5)
          <=> v3066(VarCurr,bitIndex285) )
          & ( v8936(VarNext,bitIndex4)
          <=> v3066(VarCurr,bitIndex284) )
          & ( v8936(VarNext,bitIndex3)
          <=> v3066(VarCurr,bitIndex283) )
          & ( v8936(VarNext,bitIndex2)
          <=> v3066(VarCurr,bitIndex282) )
          & ( v8936(VarNext,bitIndex1)
          <=> v3066(VarCurr,bitIndex281) )
          & ( v8936(VarNext,bitIndex0)
          <=> v3066(VarCurr,bitIndex280) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_153,axiom,
    ! [VarNext] :
      ( v8937(VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v8936(VarNext,B)
          <=> v8963(VarNext,B) ) ) ) ).

fof(addAssignment_2060,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v8963(VarNext,B)
          <=> v8961(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_216,axiom,
    ! [VarCurr] :
      ( ~ v8900(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8961(VarCurr,B)
          <=> v8964(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_206,axiom,
    ! [VarCurr] :
      ( v8900(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8961(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_82,axiom,
    ! [VarCurr] :
      ( ( ~ v8950(VarCurr)
        & ~ v8952(VarCurr) )
     => ! [B] :
          ( range_69_0(B)
         => ( v8964(VarCurr,B)
          <=> v8929(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_215,axiom,
    ! [VarCurr] :
      ( v8952(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8964(VarCurr,B)
          <=> v8922(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0_11,axiom,
    ! [VarCurr] :
      ( v8950(VarCurr)
     => ( ( v8964(VarCurr,bitIndex69)
        <=> v3066(VarCurr,bitIndex279) )
        & ( v8964(VarCurr,bitIndex68)
        <=> v3066(VarCurr,bitIndex278) )
        & ( v8964(VarCurr,bitIndex67)
        <=> v3066(VarCurr,bitIndex277) )
        & ( v8964(VarCurr,bitIndex66)
        <=> v3066(VarCurr,bitIndex276) )
        & ( v8964(VarCurr,bitIndex65)
        <=> v3066(VarCurr,bitIndex275) )
        & ( v8964(VarCurr,bitIndex64)
        <=> v3066(VarCurr,bitIndex274) )
        & ( v8964(VarCurr,bitIndex63)
        <=> v3066(VarCurr,bitIndex273) )
        & ( v8964(VarCurr,bitIndex62)
        <=> v3066(VarCurr,bitIndex272) )
        & ( v8964(VarCurr,bitIndex61)
        <=> v3066(VarCurr,bitIndex271) )
        & ( v8964(VarCurr,bitIndex60)
        <=> v3066(VarCurr,bitIndex270) )
        & ( v8964(VarCurr,bitIndex59)
        <=> v3066(VarCurr,bitIndex269) )
        & ( v8964(VarCurr,bitIndex58)
        <=> v3066(VarCurr,bitIndex268) )
        & ( v8964(VarCurr,bitIndex57)
        <=> v3066(VarCurr,bitIndex267) )
        & ( v8964(VarCurr,bitIndex56)
        <=> v3066(VarCurr,bitIndex266) )
        & ( v8964(VarCurr,bitIndex55)
        <=> v3066(VarCurr,bitIndex265) )
        & ( v8964(VarCurr,bitIndex54)
        <=> v3066(VarCurr,bitIndex264) )
        & ( v8964(VarCurr,bitIndex53)
        <=> v3066(VarCurr,bitIndex263) )
        & ( v8964(VarCurr,bitIndex52)
        <=> v3066(VarCurr,bitIndex262) )
        & ( v8964(VarCurr,bitIndex51)
        <=> v3066(VarCurr,bitIndex261) )
        & ( v8964(VarCurr,bitIndex50)
        <=> v3066(VarCurr,bitIndex260) )
        & ( v8964(VarCurr,bitIndex49)
        <=> v3066(VarCurr,bitIndex259) )
        & ( v8964(VarCurr,bitIndex48)
        <=> v3066(VarCurr,bitIndex258) )
        & ( v8964(VarCurr,bitIndex47)
        <=> v3066(VarCurr,bitIndex257) )
        & ( v8964(VarCurr,bitIndex46)
        <=> v3066(VarCurr,bitIndex256) )
        & ( v8964(VarCurr,bitIndex45)
        <=> v3066(VarCurr,bitIndex255) )
        & ( v8964(VarCurr,bitIndex44)
        <=> v3066(VarCurr,bitIndex254) )
        & ( v8964(VarCurr,bitIndex43)
        <=> v3066(VarCurr,bitIndex253) )
        & ( v8964(VarCurr,bitIndex42)
        <=> v3066(VarCurr,bitIndex252) )
        & ( v8964(VarCurr,bitIndex41)
        <=> v3066(VarCurr,bitIndex251) )
        & ( v8964(VarCurr,bitIndex40)
        <=> v3066(VarCurr,bitIndex250) )
        & ( v8964(VarCurr,bitIndex39)
        <=> v3066(VarCurr,bitIndex249) )
        & ( v8964(VarCurr,bitIndex38)
        <=> v3066(VarCurr,bitIndex248) )
        & ( v8964(VarCurr,bitIndex37)
        <=> v3066(VarCurr,bitIndex247) )
        & ( v8964(VarCurr,bitIndex36)
        <=> v3066(VarCurr,bitIndex246) )
        & ( v8964(VarCurr,bitIndex35)
        <=> v3066(VarCurr,bitIndex245) )
        & ( v8964(VarCurr,bitIndex34)
        <=> v3066(VarCurr,bitIndex244) )
        & ( v8964(VarCurr,bitIndex33)
        <=> v3066(VarCurr,bitIndex243) )
        & ( v8964(VarCurr,bitIndex32)
        <=> v3066(VarCurr,bitIndex242) )
        & ( v8964(VarCurr,bitIndex31)
        <=> v3066(VarCurr,bitIndex241) )
        & ( v8964(VarCurr,bitIndex30)
        <=> v3066(VarCurr,bitIndex240) )
        & ( v8964(VarCurr,bitIndex29)
        <=> v3066(VarCurr,bitIndex239) )
        & ( v8964(VarCurr,bitIndex28)
        <=> v3066(VarCurr,bitIndex238) )
        & ( v8964(VarCurr,bitIndex27)
        <=> v3066(VarCurr,bitIndex237) )
        & ( v8964(VarCurr,bitIndex26)
        <=> v3066(VarCurr,bitIndex236) )
        & ( v8964(VarCurr,bitIndex25)
        <=> v3066(VarCurr,bitIndex235) )
        & ( v8964(VarCurr,bitIndex24)
        <=> v3066(VarCurr,bitIndex234) )
        & ( v8964(VarCurr,bitIndex23)
        <=> v3066(VarCurr,bitIndex233) )
        & ( v8964(VarCurr,bitIndex22)
        <=> v3066(VarCurr,bitIndex232) )
        & ( v8964(VarCurr,bitIndex21)
        <=> v3066(VarCurr,bitIndex231) )
        & ( v8964(VarCurr,bitIndex20)
        <=> v3066(VarCurr,bitIndex230) )
        & ( v8964(VarCurr,bitIndex19)
        <=> v3066(VarCurr,bitIndex229) )
        & ( v8964(VarCurr,bitIndex18)
        <=> v3066(VarCurr,bitIndex228) )
        & ( v8964(VarCurr,bitIndex17)
        <=> v3066(VarCurr,bitIndex227) )
        & ( v8964(VarCurr,bitIndex16)
        <=> v3066(VarCurr,bitIndex226) )
        & ( v8964(VarCurr,bitIndex15)
        <=> v3066(VarCurr,bitIndex225) )
        & ( v8964(VarCurr,bitIndex14)
        <=> v3066(VarCurr,bitIndex224) )
        & ( v8964(VarCurr,bitIndex13)
        <=> v3066(VarCurr,bitIndex223) )
        & ( v8964(VarCurr,bitIndex12)
        <=> v3066(VarCurr,bitIndex222) )
        & ( v8964(VarCurr,bitIndex11)
        <=> v3066(VarCurr,bitIndex221) )
        & ( v8964(VarCurr,bitIndex10)
        <=> v3066(VarCurr,bitIndex220) )
        & ( v8964(VarCurr,bitIndex9)
        <=> v3066(VarCurr,bitIndex219) )
        & ( v8964(VarCurr,bitIndex8)
        <=> v3066(VarCurr,bitIndex218) )
        & ( v8964(VarCurr,bitIndex7)
        <=> v3066(VarCurr,bitIndex217) )
        & ( v8964(VarCurr,bitIndex6)
        <=> v3066(VarCurr,bitIndex216) )
        & ( v8964(VarCurr,bitIndex5)
        <=> v3066(VarCurr,bitIndex215) )
        & ( v8964(VarCurr,bitIndex4)
        <=> v3066(VarCurr,bitIndex214) )
        & ( v8964(VarCurr,bitIndex3)
        <=> v3066(VarCurr,bitIndex213) )
        & ( v8964(VarCurr,bitIndex2)
        <=> v3066(VarCurr,bitIndex212) )
        & ( v8964(VarCurr,bitIndex1)
        <=> v3066(VarCurr,bitIndex211) )
        & ( v8964(VarCurr,bitIndex0)
        <=> v3066(VarCurr,bitIndex210) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1681,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8937(VarNext)
      <=> ( v8938(VarNext)
          & v8945(VarNext) ) ) ) ).

fof(addAssignment_2059,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8945(VarNext)
      <=> v8943(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1680,axiom,
    ! [VarCurr] :
      ( v8943(VarCurr)
    <=> ( v8946(VarCurr)
        & v8957(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1679,axiom,
    ! [VarCurr] :
      ( v8957(VarCurr)
    <=> ( v8958(VarCurr)
        | v8900(VarCurr) ) ) ).

fof(writeUnaryOperator_786,axiom,
    ! [VarCurr] :
      ( ~ v8958(VarCurr)
    <=> v8959(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_632,axiom,
    ! [VarCurr] :
      ( v8959(VarCurr)
    <=> ( ( v8960(VarCurr,bitIndex1)
        <=> $false )
        & ( v8960(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2058,axiom,
    ! [VarCurr] :
      ( v8960(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2057,axiom,
    ! [VarCurr] :
      ( v8960(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1678,axiom,
    ! [VarCurr] :
      ( v8946(VarCurr)
    <=> ( v8900(VarCurr)
        | v8947(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1677,axiom,
    ! [VarCurr] :
      ( v8947(VarCurr)
    <=> ( v8948(VarCurr)
        & v8956(VarCurr) ) ) ).

fof(writeUnaryOperator_785,axiom,
    ! [VarCurr] :
      ( ~ v8956(VarCurr)
    <=> v8900(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1676,axiom,
    ! [VarCurr] :
      ( v8948(VarCurr)
    <=> ( v8949(VarCurr)
        | v8954(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_631,axiom,
    ! [VarCurr] :
      ( v8954(VarCurr)
    <=> ( ( v8955(VarCurr,bitIndex1)
        <=> $true )
        & ( v8955(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2056,axiom,
    ! [VarCurr] :
      ( v8955(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2055,axiom,
    ! [VarCurr] :
      ( v8955(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1675,axiom,
    ! [VarCurr] :
      ( v8949(VarCurr)
    <=> ( v8950(VarCurr)
        | v8952(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_630,axiom,
    ! [VarCurr] :
      ( v8952(VarCurr)
    <=> ( ( v8953(VarCurr,bitIndex1)
        <=> $true )
        & ( v8953(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2054,axiom,
    ! [VarCurr] :
      ( v8953(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2053,axiom,
    ! [VarCurr] :
      ( v8953(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_629,axiom,
    ! [VarCurr] :
      ( v8950(VarCurr)
    <=> ( ( v8951(VarCurr,bitIndex1)
        <=> $false )
        & ( v8951(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2052,axiom,
    ! [VarCurr] :
      ( v8951(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2051,axiom,
    ! [VarCurr] :
      ( v8951(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1674,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8938(VarNext)
      <=> ( v8940(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_784,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8940(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2050,axiom,
    ! [VarCurr] :
      ( v8929(VarCurr,bitIndex49)
    <=> v8934(VarCurr,bitIndex49) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_215,axiom,
    ! [VarCurr] :
      ( ~ v8931(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8934(VarCurr,B)
          <=> v8933(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_218,axiom,
    ! [VarCurr] :
      ( v8931(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8934(VarCurr,B)
          <=> v3163(VarCurr,B) ) ) ) ).

fof(addAssignment_2049,axiom,
    ! [VarCurr] :
      ( v8933(VarCurr,bitIndex49)
    <=> v3066(VarCurr,bitIndex259) ) ).

fof(addAssignment_2048,axiom,
    ! [VarCurr] :
      ( v8931(VarCurr)
    <=> v3073(VarCurr,bitIndex4) ) ).

fof(addAssignment_2047,axiom,
    ! [VarCurr] :
      ( v8922(VarCurr,bitIndex49)
    <=> v8927(VarCurr,bitIndex49) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_214,axiom,
    ! [VarCurr] :
      ( ~ v8924(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8927(VarCurr,B)
          <=> v8926(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_217,axiom,
    ! [VarCurr] :
      ( v8924(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8927(VarCurr,B)
          <=> v3163(VarCurr,B) ) ) ) ).

fof(addAssignment_2046,axiom,
    ! [VarCurr] :
      ( v8926(VarCurr,bitIndex49)
    <=> v3066(VarCurr,bitIndex329) ) ).

fof(addAssignment_2045,axiom,
    ! [VarCurr] :
      ( v8924(VarCurr)
    <=> v3073(VarCurr,bitIndex4) ) ).

fof(addAssignment_2044,axiom,
    ! [VarNext] :
      ( v3066(VarNext,bitIndex259)
    <=> v8889(VarNext,bitIndex49) ) ).

fof(addCaseBooleanConditionShiftedRanges1_18,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8890(VarNext)
       => ( ( v8889(VarNext,bitIndex69)
          <=> v3066(VarCurr,bitIndex279) )
          & ( v8889(VarNext,bitIndex68)
          <=> v3066(VarCurr,bitIndex278) )
          & ( v8889(VarNext,bitIndex67)
          <=> v3066(VarCurr,bitIndex277) )
          & ( v8889(VarNext,bitIndex66)
          <=> v3066(VarCurr,bitIndex276) )
          & ( v8889(VarNext,bitIndex65)
          <=> v3066(VarCurr,bitIndex275) )
          & ( v8889(VarNext,bitIndex64)
          <=> v3066(VarCurr,bitIndex274) )
          & ( v8889(VarNext,bitIndex63)
          <=> v3066(VarCurr,bitIndex273) )
          & ( v8889(VarNext,bitIndex62)
          <=> v3066(VarCurr,bitIndex272) )
          & ( v8889(VarNext,bitIndex61)
          <=> v3066(VarCurr,bitIndex271) )
          & ( v8889(VarNext,bitIndex60)
          <=> v3066(VarCurr,bitIndex270) )
          & ( v8889(VarNext,bitIndex59)
          <=> v3066(VarCurr,bitIndex269) )
          & ( v8889(VarNext,bitIndex58)
          <=> v3066(VarCurr,bitIndex268) )
          & ( v8889(VarNext,bitIndex57)
          <=> v3066(VarCurr,bitIndex267) )
          & ( v8889(VarNext,bitIndex56)
          <=> v3066(VarCurr,bitIndex266) )
          & ( v8889(VarNext,bitIndex55)
          <=> v3066(VarCurr,bitIndex265) )
          & ( v8889(VarNext,bitIndex54)
          <=> v3066(VarCurr,bitIndex264) )
          & ( v8889(VarNext,bitIndex53)
          <=> v3066(VarCurr,bitIndex263) )
          & ( v8889(VarNext,bitIndex52)
          <=> v3066(VarCurr,bitIndex262) )
          & ( v8889(VarNext,bitIndex51)
          <=> v3066(VarCurr,bitIndex261) )
          & ( v8889(VarNext,bitIndex50)
          <=> v3066(VarCurr,bitIndex260) )
          & ( v8889(VarNext,bitIndex49)
          <=> v3066(VarCurr,bitIndex259) )
          & ( v8889(VarNext,bitIndex48)
          <=> v3066(VarCurr,bitIndex258) )
          & ( v8889(VarNext,bitIndex47)
          <=> v3066(VarCurr,bitIndex257) )
          & ( v8889(VarNext,bitIndex46)
          <=> v3066(VarCurr,bitIndex256) )
          & ( v8889(VarNext,bitIndex45)
          <=> v3066(VarCurr,bitIndex255) )
          & ( v8889(VarNext,bitIndex44)
          <=> v3066(VarCurr,bitIndex254) )
          & ( v8889(VarNext,bitIndex43)
          <=> v3066(VarCurr,bitIndex253) )
          & ( v8889(VarNext,bitIndex42)
          <=> v3066(VarCurr,bitIndex252) )
          & ( v8889(VarNext,bitIndex41)
          <=> v3066(VarCurr,bitIndex251) )
          & ( v8889(VarNext,bitIndex40)
          <=> v3066(VarCurr,bitIndex250) )
          & ( v8889(VarNext,bitIndex39)
          <=> v3066(VarCurr,bitIndex249) )
          & ( v8889(VarNext,bitIndex38)
          <=> v3066(VarCurr,bitIndex248) )
          & ( v8889(VarNext,bitIndex37)
          <=> v3066(VarCurr,bitIndex247) )
          & ( v8889(VarNext,bitIndex36)
          <=> v3066(VarCurr,bitIndex246) )
          & ( v8889(VarNext,bitIndex35)
          <=> v3066(VarCurr,bitIndex245) )
          & ( v8889(VarNext,bitIndex34)
          <=> v3066(VarCurr,bitIndex244) )
          & ( v8889(VarNext,bitIndex33)
          <=> v3066(VarCurr,bitIndex243) )
          & ( v8889(VarNext,bitIndex32)
          <=> v3066(VarCurr,bitIndex242) )
          & ( v8889(VarNext,bitIndex31)
          <=> v3066(VarCurr,bitIndex241) )
          & ( v8889(VarNext,bitIndex30)
          <=> v3066(VarCurr,bitIndex240) )
          & ( v8889(VarNext,bitIndex29)
          <=> v3066(VarCurr,bitIndex239) )
          & ( v8889(VarNext,bitIndex28)
          <=> v3066(VarCurr,bitIndex238) )
          & ( v8889(VarNext,bitIndex27)
          <=> v3066(VarCurr,bitIndex237) )
          & ( v8889(VarNext,bitIndex26)
          <=> v3066(VarCurr,bitIndex236) )
          & ( v8889(VarNext,bitIndex25)
          <=> v3066(VarCurr,bitIndex235) )
          & ( v8889(VarNext,bitIndex24)
          <=> v3066(VarCurr,bitIndex234) )
          & ( v8889(VarNext,bitIndex23)
          <=> v3066(VarCurr,bitIndex233) )
          & ( v8889(VarNext,bitIndex22)
          <=> v3066(VarCurr,bitIndex232) )
          & ( v8889(VarNext,bitIndex21)
          <=> v3066(VarCurr,bitIndex231) )
          & ( v8889(VarNext,bitIndex20)
          <=> v3066(VarCurr,bitIndex230) )
          & ( v8889(VarNext,bitIndex19)
          <=> v3066(VarCurr,bitIndex229) )
          & ( v8889(VarNext,bitIndex18)
          <=> v3066(VarCurr,bitIndex228) )
          & ( v8889(VarNext,bitIndex17)
          <=> v3066(VarCurr,bitIndex227) )
          & ( v8889(VarNext,bitIndex16)
          <=> v3066(VarCurr,bitIndex226) )
          & ( v8889(VarNext,bitIndex15)
          <=> v3066(VarCurr,bitIndex225) )
          & ( v8889(VarNext,bitIndex14)
          <=> v3066(VarCurr,bitIndex224) )
          & ( v8889(VarNext,bitIndex13)
          <=> v3066(VarCurr,bitIndex223) )
          & ( v8889(VarNext,bitIndex12)
          <=> v3066(VarCurr,bitIndex222) )
          & ( v8889(VarNext,bitIndex11)
          <=> v3066(VarCurr,bitIndex221) )
          & ( v8889(VarNext,bitIndex10)
          <=> v3066(VarCurr,bitIndex220) )
          & ( v8889(VarNext,bitIndex9)
          <=> v3066(VarCurr,bitIndex219) )
          & ( v8889(VarNext,bitIndex8)
          <=> v3066(VarCurr,bitIndex218) )
          & ( v8889(VarNext,bitIndex7)
          <=> v3066(VarCurr,bitIndex217) )
          & ( v8889(VarNext,bitIndex6)
          <=> v3066(VarCurr,bitIndex216) )
          & ( v8889(VarNext,bitIndex5)
          <=> v3066(VarCurr,bitIndex215) )
          & ( v8889(VarNext,bitIndex4)
          <=> v3066(VarCurr,bitIndex214) )
          & ( v8889(VarNext,bitIndex3)
          <=> v3066(VarCurr,bitIndex213) )
          & ( v8889(VarNext,bitIndex2)
          <=> v3066(VarCurr,bitIndex212) )
          & ( v8889(VarNext,bitIndex1)
          <=> v3066(VarCurr,bitIndex211) )
          & ( v8889(VarNext,bitIndex0)
          <=> v3066(VarCurr,bitIndex210) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_152,axiom,
    ! [VarNext] :
      ( v8890(VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v8889(VarNext,B)
          <=> v8917(VarNext,B) ) ) ) ).

fof(addAssignment_2043,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_69_0(B)
         => ( v8917(VarNext,B)
          <=> v8915(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_214,axiom,
    ! [VarCurr] :
      ( ~ v8900(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8915(VarCurr,B)
          <=> v8918(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_205,axiom,
    ! [VarCurr] :
      ( v8900(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8915(VarCurr,B)
          <=> $false ) ) ) ).

fof(bitBlastConstant_907,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex69) ).

fof(bitBlastConstant_906,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex68) ).

fof(bitBlastConstant_905,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex67) ).

fof(bitBlastConstant_904,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex66) ).

fof(bitBlastConstant_903,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex65) ).

fof(bitBlastConstant_902,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex64) ).

fof(bitBlastConstant_901,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex63) ).

fof(bitBlastConstant_900,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex62) ).

fof(bitBlastConstant_899,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex61) ).

fof(bitBlastConstant_898,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex60) ).

fof(bitBlastConstant_897,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex59) ).

fof(bitBlastConstant_896,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex58) ).

fof(bitBlastConstant_895,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex57) ).

fof(bitBlastConstant_894,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex56) ).

fof(bitBlastConstant_893,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex55) ).

fof(bitBlastConstant_892,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex54) ).

fof(bitBlastConstant_891,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex53) ).

fof(bitBlastConstant_890,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex52) ).

fof(bitBlastConstant_889,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex51) ).

fof(bitBlastConstant_888,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex50) ).

fof(bitBlastConstant_887,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex49) ).

fof(bitBlastConstant_886,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex48) ).

fof(bitBlastConstant_885,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex47) ).

fof(bitBlastConstant_884,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex46) ).

fof(bitBlastConstant_883,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex45) ).

fof(bitBlastConstant_882,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex44) ).

fof(bitBlastConstant_881,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex43) ).

fof(bitBlastConstant_880,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex42) ).

fof(bitBlastConstant_879,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex41) ).

fof(bitBlastConstant_878,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex40) ).

fof(bitBlastConstant_877,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex39) ).

fof(bitBlastConstant_876,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex38) ).

fof(bitBlastConstant_875,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex37) ).

fof(bitBlastConstant_874,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex36) ).

fof(bitBlastConstant_873,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex35) ).

fof(bitBlastConstant_872,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex34) ).

fof(bitBlastConstant_871,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex33) ).

fof(bitBlastConstant_870,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex32) ).

fof(bitBlastConstant_869,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex31) ).

fof(bitBlastConstant_868,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex30) ).

fof(bitBlastConstant_867,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex29) ).

fof(bitBlastConstant_866,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex28) ).

fof(bitBlastConstant_865,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex27) ).

fof(bitBlastConstant_864,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex26) ).

fof(bitBlastConstant_863,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex25) ).

fof(bitBlastConstant_862,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex24) ).

fof(bitBlastConstant_861,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex23) ).

fof(bitBlastConstant_860,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex22) ).

fof(bitBlastConstant_859,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex21) ).

fof(bitBlastConstant_858,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex20) ).

fof(bitBlastConstant_857,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex19) ).

fof(bitBlastConstant_856,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex18) ).

fof(bitBlastConstant_855,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex17) ).

fof(bitBlastConstant_854,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex16) ).

fof(bitBlastConstant_853,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex15) ).

fof(bitBlastConstant_852,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex14) ).

fof(bitBlastConstant_851,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex13) ).

fof(bitBlastConstant_850,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex12) ).

fof(bitBlastConstant_849,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex11) ).

fof(bitBlastConstant_848,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex10) ).

fof(bitBlastConstant_847,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex9) ).

fof(bitBlastConstant_846,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex8) ).

fof(bitBlastConstant_845,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex7) ).

fof(bitBlastConstant_844,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex6) ).

fof(bitBlastConstant_843,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex5) ).

fof(bitBlastConstant_842,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex4) ).

fof(bitBlastConstant_841,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex3) ).

fof(bitBlastConstant_840,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex2) ).

fof(bitBlastConstant_839,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex1) ).

fof(bitBlastConstant_838,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000000(bitIndex0) ).

fof(addParallelCaseBooleanConditionEqualRanges2_81,axiom,
    ! [VarCurr] :
      ( ( ~ v8904(VarCurr)
        & ~ v8906(VarCurr) )
     => ! [B] :
          ( range_69_0(B)
         => ( v8918(VarCurr,B)
          <=> v8882(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_213,axiom,
    ! [VarCurr] :
      ( v8906(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8918(VarCurr,B)
          <=> v3069(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0_10,axiom,
    ! [VarCurr] :
      ( v8904(VarCurr)
     => ( ( v8918(VarCurr,bitIndex69)
        <=> v3066(VarCurr,bitIndex209) )
        & ( v8918(VarCurr,bitIndex68)
        <=> v3066(VarCurr,bitIndex208) )
        & ( v8918(VarCurr,bitIndex67)
        <=> v3066(VarCurr,bitIndex207) )
        & ( v8918(VarCurr,bitIndex66)
        <=> v3066(VarCurr,bitIndex206) )
        & ( v8918(VarCurr,bitIndex65)
        <=> v3066(VarCurr,bitIndex205) )
        & ( v8918(VarCurr,bitIndex64)
        <=> v3066(VarCurr,bitIndex204) )
        & ( v8918(VarCurr,bitIndex63)
        <=> v3066(VarCurr,bitIndex203) )
        & ( v8918(VarCurr,bitIndex62)
        <=> v3066(VarCurr,bitIndex202) )
        & ( v8918(VarCurr,bitIndex61)
        <=> v3066(VarCurr,bitIndex201) )
        & ( v8918(VarCurr,bitIndex60)
        <=> v3066(VarCurr,bitIndex200) )
        & ( v8918(VarCurr,bitIndex59)
        <=> v3066(VarCurr,bitIndex199) )
        & ( v8918(VarCurr,bitIndex58)
        <=> v3066(VarCurr,bitIndex198) )
        & ( v8918(VarCurr,bitIndex57)
        <=> v3066(VarCurr,bitIndex197) )
        & ( v8918(VarCurr,bitIndex56)
        <=> v3066(VarCurr,bitIndex196) )
        & ( v8918(VarCurr,bitIndex55)
        <=> v3066(VarCurr,bitIndex195) )
        & ( v8918(VarCurr,bitIndex54)
        <=> v3066(VarCurr,bitIndex194) )
        & ( v8918(VarCurr,bitIndex53)
        <=> v3066(VarCurr,bitIndex193) )
        & ( v8918(VarCurr,bitIndex52)
        <=> v3066(VarCurr,bitIndex192) )
        & ( v8918(VarCurr,bitIndex51)
        <=> v3066(VarCurr,bitIndex191) )
        & ( v8918(VarCurr,bitIndex50)
        <=> v3066(VarCurr,bitIndex190) )
        & ( v8918(VarCurr,bitIndex49)
        <=> v3066(VarCurr,bitIndex189) )
        & ( v8918(VarCurr,bitIndex48)
        <=> v3066(VarCurr,bitIndex188) )
        & ( v8918(VarCurr,bitIndex47)
        <=> v3066(VarCurr,bitIndex187) )
        & ( v8918(VarCurr,bitIndex46)
        <=> v3066(VarCurr,bitIndex186) )
        & ( v8918(VarCurr,bitIndex45)
        <=> v3066(VarCurr,bitIndex185) )
        & ( v8918(VarCurr,bitIndex44)
        <=> v3066(VarCurr,bitIndex184) )
        & ( v8918(VarCurr,bitIndex43)
        <=> v3066(VarCurr,bitIndex183) )
        & ( v8918(VarCurr,bitIndex42)
        <=> v3066(VarCurr,bitIndex182) )
        & ( v8918(VarCurr,bitIndex41)
        <=> v3066(VarCurr,bitIndex181) )
        & ( v8918(VarCurr,bitIndex40)
        <=> v3066(VarCurr,bitIndex180) )
        & ( v8918(VarCurr,bitIndex39)
        <=> v3066(VarCurr,bitIndex179) )
        & ( v8918(VarCurr,bitIndex38)
        <=> v3066(VarCurr,bitIndex178) )
        & ( v8918(VarCurr,bitIndex37)
        <=> v3066(VarCurr,bitIndex177) )
        & ( v8918(VarCurr,bitIndex36)
        <=> v3066(VarCurr,bitIndex176) )
        & ( v8918(VarCurr,bitIndex35)
        <=> v3066(VarCurr,bitIndex175) )
        & ( v8918(VarCurr,bitIndex34)
        <=> v3066(VarCurr,bitIndex174) )
        & ( v8918(VarCurr,bitIndex33)
        <=> v3066(VarCurr,bitIndex173) )
        & ( v8918(VarCurr,bitIndex32)
        <=> v3066(VarCurr,bitIndex172) )
        & ( v8918(VarCurr,bitIndex31)
        <=> v3066(VarCurr,bitIndex171) )
        & ( v8918(VarCurr,bitIndex30)
        <=> v3066(VarCurr,bitIndex170) )
        & ( v8918(VarCurr,bitIndex29)
        <=> v3066(VarCurr,bitIndex169) )
        & ( v8918(VarCurr,bitIndex28)
        <=> v3066(VarCurr,bitIndex168) )
        & ( v8918(VarCurr,bitIndex27)
        <=> v3066(VarCurr,bitIndex167) )
        & ( v8918(VarCurr,bitIndex26)
        <=> v3066(VarCurr,bitIndex166) )
        & ( v8918(VarCurr,bitIndex25)
        <=> v3066(VarCurr,bitIndex165) )
        & ( v8918(VarCurr,bitIndex24)
        <=> v3066(VarCurr,bitIndex164) )
        & ( v8918(VarCurr,bitIndex23)
        <=> v3066(VarCurr,bitIndex163) )
        & ( v8918(VarCurr,bitIndex22)
        <=> v3066(VarCurr,bitIndex162) )
        & ( v8918(VarCurr,bitIndex21)
        <=> v3066(VarCurr,bitIndex161) )
        & ( v8918(VarCurr,bitIndex20)
        <=> v3066(VarCurr,bitIndex160) )
        & ( v8918(VarCurr,bitIndex19)
        <=> v3066(VarCurr,bitIndex159) )
        & ( v8918(VarCurr,bitIndex18)
        <=> v3066(VarCurr,bitIndex158) )
        & ( v8918(VarCurr,bitIndex17)
        <=> v3066(VarCurr,bitIndex157) )
        & ( v8918(VarCurr,bitIndex16)
        <=> v3066(VarCurr,bitIndex156) )
        & ( v8918(VarCurr,bitIndex15)
        <=> v3066(VarCurr,bitIndex155) )
        & ( v8918(VarCurr,bitIndex14)
        <=> v3066(VarCurr,bitIndex154) )
        & ( v8918(VarCurr,bitIndex13)
        <=> v3066(VarCurr,bitIndex153) )
        & ( v8918(VarCurr,bitIndex12)
        <=> v3066(VarCurr,bitIndex152) )
        & ( v8918(VarCurr,bitIndex11)
        <=> v3066(VarCurr,bitIndex151) )
        & ( v8918(VarCurr,bitIndex10)
        <=> v3066(VarCurr,bitIndex150) )
        & ( v8918(VarCurr,bitIndex9)
        <=> v3066(VarCurr,bitIndex149) )
        & ( v8918(VarCurr,bitIndex8)
        <=> v3066(VarCurr,bitIndex148) )
        & ( v8918(VarCurr,bitIndex7)
        <=> v3066(VarCurr,bitIndex147) )
        & ( v8918(VarCurr,bitIndex6)
        <=> v3066(VarCurr,bitIndex146) )
        & ( v8918(VarCurr,bitIndex5)
        <=> v3066(VarCurr,bitIndex145) )
        & ( v8918(VarCurr,bitIndex4)
        <=> v3066(VarCurr,bitIndex144) )
        & ( v8918(VarCurr,bitIndex3)
        <=> v3066(VarCurr,bitIndex143) )
        & ( v8918(VarCurr,bitIndex2)
        <=> v3066(VarCurr,bitIndex142) )
        & ( v8918(VarCurr,bitIndex1)
        <=> v3066(VarCurr,bitIndex141) )
        & ( v8918(VarCurr,bitIndex0)
        <=> v3066(VarCurr,bitIndex140) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1673,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8890(VarNext)
      <=> ( v8891(VarNext)
          & v8898(VarNext) ) ) ) ).

fof(addAssignment_2042,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8898(VarNext)
      <=> v8896(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1672,axiom,
    ! [VarCurr] :
      ( v8896(VarCurr)
    <=> ( v8899(VarCurr)
        & v8911(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1671,axiom,
    ! [VarCurr] :
      ( v8911(VarCurr)
    <=> ( v8912(VarCurr)
        | v8900(VarCurr) ) ) ).

fof(writeUnaryOperator_783,axiom,
    ! [VarCurr] :
      ( ~ v8912(VarCurr)
    <=> v8913(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_628,axiom,
    ! [VarCurr] :
      ( v8913(VarCurr)
    <=> ( ( v8914(VarCurr,bitIndex1)
        <=> $false )
        & ( v8914(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2041,axiom,
    ! [VarCurr] :
      ( v8914(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2040,axiom,
    ! [VarCurr] :
      ( v8914(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1670,axiom,
    ! [VarCurr] :
      ( v8899(VarCurr)
    <=> ( v8900(VarCurr)
        | v8901(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1669,axiom,
    ! [VarCurr] :
      ( v8901(VarCurr)
    <=> ( v8902(VarCurr)
        & v8910(VarCurr) ) ) ).

fof(writeUnaryOperator_782,axiom,
    ! [VarCurr] :
      ( ~ v8910(VarCurr)
    <=> v8900(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1668,axiom,
    ! [VarCurr] :
      ( v8902(VarCurr)
    <=> ( v8903(VarCurr)
        | v8908(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_627,axiom,
    ! [VarCurr] :
      ( v8908(VarCurr)
    <=> ( ( v8909(VarCurr,bitIndex1)
        <=> $true )
        & ( v8909(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2039,axiom,
    ! [VarCurr] :
      ( v8909(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2038,axiom,
    ! [VarCurr] :
      ( v8909(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1667,axiom,
    ! [VarCurr] :
      ( v8903(VarCurr)
    <=> ( v8904(VarCurr)
        | v8906(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_626,axiom,
    ! [VarCurr] :
      ( v8906(VarCurr)
    <=> ( ( v8907(VarCurr,bitIndex1)
        <=> $true )
        & ( v8907(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2037,axiom,
    ! [VarCurr] :
      ( v8907(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2036,axiom,
    ! [VarCurr] :
      ( v8907(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_625,axiom,
    ! [VarCurr] :
      ( v8904(VarCurr)
    <=> ( ( v8905(VarCurr,bitIndex1)
        <=> $false )
        & ( v8905(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2035,axiom,
    ! [VarCurr] :
      ( v8905(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_2034,axiom,
    ! [VarCurr] :
      ( v8905(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(writeUnaryOperator_781,axiom,
    ! [VarCurr] :
      ( ~ v8900(VarCurr)
    <=> v33(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1666,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8891(VarNext)
      <=> ( v8892(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_780,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8892(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_2033,axiom,
    ! [VarCurr] :
      ( v8882(VarCurr,bitIndex49)
    <=> v8887(VarCurr,bitIndex49) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_213,axiom,
    ! [VarCurr] :
      ( ~ v8884(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8887(VarCurr,B)
          <=> v8886(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_216,axiom,
    ! [VarCurr] :
      ( v8884(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8887(VarCurr,B)
          <=> v3163(VarCurr,B) ) ) ) ).

fof(addAssignment_2032,axiom,
    ! [VarCurr] :
      ( v8886(VarCurr,bitIndex49)
    <=> v3066(VarCurr,bitIndex189) ) ).

fof(addAssignment_2031,axiom,
    ! [VarCurr] :
      ( v8884(VarCurr)
    <=> v3073(VarCurr,bitIndex5) ) ).

fof(addAssignment_2030,axiom,
    ! [VarCurr] :
      ( v3069(VarCurr,bitIndex49)
    <=> v8880(VarCurr,bitIndex49) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_212,axiom,
    ! [VarCurr] :
      ( ~ v3071(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8880(VarCurr,B)
          <=> v8871(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_215,axiom,
    ! [VarCurr] :
      ( v3071(VarCurr)
     => ! [B] :
          ( range_69_0(B)
         => ( v8880(VarCurr,B)
          <=> v3163(VarCurr,B) ) ) ) ).

fof(range_axiom_51,axiom,
    ! [B] :
      ( range_69_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B
        | bitIndex11 = B
        | bitIndex12 = B
        | bitIndex13 = B
        | bitIndex14 = B
        | bitIndex15 = B
        | bitIndex16 = B
        | bitIndex17 = B
        | bitIndex18 = B
        | bitIndex19 = B
        | bitIndex20 = B
        | bitIndex21 = B
        | bitIndex22 = B
        | bitIndex23 = B
        | bitIndex24 = B
        | bitIndex25 = B
        | bitIndex26 = B
        | bitIndex27 = B
        | bitIndex28 = B
        | bitIndex29 = B
        | bitIndex30 = B
        | bitIndex31 = B
        | bitIndex32 = B
        | bitIndex33 = B
        | bitIndex34 = B
        | bitIndex35 = B
        | bitIndex36 = B
        | bitIndex37 = B
        | bitIndex38 = B
        | bitIndex39 = B
        | bitIndex40 = B
        | bitIndex41 = B
        | bitIndex42 = B
        | bitIndex43 = B
        | bitIndex44 = B
        | bitIndex45 = B
        | bitIndex46 = B
        | bitIndex47 = B
        | bitIndex48 = B
        | bitIndex49 = B
        | bitIndex50 = B
        | bitIndex51 = B
        | bitIndex52 = B
        | bitIndex53 = B
        | bitIndex54 = B
        | bitIndex55 = B
        | bitIndex56 = B
        | bitIndex57 = B
        | bitIndex58 = B
        | bitIndex59 = B
        | bitIndex60 = B
        | bitIndex61 = B
        | bitIndex62 = B
        | bitIndex63 = B
        | bitIndex64 = B
        | bitIndex65 = B
        | bitIndex66 = B
        | bitIndex67 = B
        | bitIndex68 = B
        | bitIndex69 = B ) ) ).

fof(addAssignment_2029,axiom,
    ! [VarCurr] :
      ( v8871(VarCurr,bitIndex49)
    <=> v3066(VarCurr,bitIndex259) ) ).

fof(addAssignmentInitValue_141,axiom,
    ~ v3066(constB0,bitIndex559) ).

fof(addAssignmentInitValue_140,axiom,
    ~ v3066(constB0,bitIndex558) ).

fof(addAssignmentInitValue_139,axiom,
    ~ v3066(constB0,bitIndex557) ).

fof(addAssignmentInitValue_138,axiom,
    ~ v3066(constB0,bitIndex556) ).

fof(addAssignmentInitValue_137,axiom,
    ~ v3066(constB0,bitIndex555) ).

fof(addAssignmentInitValue_136,axiom,
    ~ v3066(constB0,bitIndex554) ).

fof(addAssignmentInitValue_135,axiom,
    ~ v3066(constB0,bitIndex553) ).

fof(addAssignmentInitValue_134,axiom,
    ~ v3066(constB0,bitIndex539) ).

fof(bitBlastConstant_837,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex69) ).

fof(bitBlastConstant_836,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex68) ).

fof(bitBlastConstant_835,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex67) ).

fof(bitBlastConstant_834,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex66) ).

fof(bitBlastConstant_833,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex65) ).

fof(bitBlastConstant_832,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex64) ).

fof(bitBlastConstant_831,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex63) ).

fof(bitBlastConstant_830,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex49) ).

fof(addAssignmentInitValue_133,axiom,
    ~ v3066(constB0,bitIndex489) ).

fof(addAssignmentInitValue_132,axiom,
    ~ v3066(constB0,bitIndex488) ).

fof(addAssignmentInitValue_131,axiom,
    ~ v3066(constB0,bitIndex487) ).

fof(addAssignmentInitValue_130,axiom,
    ~ v3066(constB0,bitIndex486) ).

fof(addAssignmentInitValue_129,axiom,
    ~ v3066(constB0,bitIndex485) ).

fof(addAssignmentInitValue_128,axiom,
    ~ v3066(constB0,bitIndex484) ).

fof(addAssignmentInitValue_127,axiom,
    ~ v3066(constB0,bitIndex483) ).

fof(addAssignmentInitValue_126,axiom,
    ~ v3066(constB0,bitIndex469) ).

fof(bitBlastConstant_829,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex69) ).

fof(bitBlastConstant_828,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex68) ).

fof(bitBlastConstant_827,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex67) ).

fof(bitBlastConstant_826,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex66) ).

fof(bitBlastConstant_825,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex65) ).

fof(bitBlastConstant_824,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex64) ).

fof(bitBlastConstant_823,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex63) ).

fof(bitBlastConstant_822,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex49) ).

fof(addAssignmentInitValue_125,axiom,
    ~ v3066(constB0,bitIndex419) ).

fof(addAssignmentInitValue_124,axiom,
    ~ v3066(constB0,bitIndex418) ).

fof(addAssignmentInitValue_123,axiom,
    ~ v3066(constB0,bitIndex417) ).

fof(addAssignmentInitValue_122,axiom,
    ~ v3066(constB0,bitIndex416) ).

fof(addAssignmentInitValue_121,axiom,
    ~ v3066(constB0,bitIndex415) ).

fof(addAssignmentInitValue_120,axiom,
    ~ v3066(constB0,bitIndex414) ).

fof(addAssignmentInitValue_119,axiom,
    ~ v3066(constB0,bitIndex413) ).

fof(addAssignmentInitValue_118,axiom,
    ~ v3066(constB0,bitIndex399) ).

fof(bitBlastConstant_821,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex69) ).

fof(bitBlastConstant_820,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex68) ).

fof(bitBlastConstant_819,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex67) ).

fof(bitBlastConstant_818,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex66) ).

fof(bitBlastConstant_817,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex65) ).

fof(bitBlastConstant_816,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex64) ).

fof(bitBlastConstant_815,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex63) ).

fof(bitBlastConstant_814,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex49) ).

fof(addAssignmentInitValue_117,axiom,
    ~ v3066(constB0,bitIndex349) ).

fof(addAssignmentInitValue_116,axiom,
    ~ v3066(constB0,bitIndex348) ).

fof(addAssignmentInitValue_115,axiom,
    ~ v3066(constB0,bitIndex347) ).

fof(addAssignmentInitValue_114,axiom,
    ~ v3066(constB0,bitIndex346) ).

fof(addAssignmentInitValue_113,axiom,
    ~ v3066(constB0,bitIndex345) ).

fof(addAssignmentInitValue_112,axiom,
    ~ v3066(constB0,bitIndex344) ).

fof(addAssignmentInitValue_111,axiom,
    ~ v3066(constB0,bitIndex343) ).

fof(addAssignmentInitValue_110,axiom,
    ~ v3066(constB0,bitIndex329) ).

fof(bitBlastConstant_813,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex69) ).

fof(bitBlastConstant_812,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex68) ).

fof(bitBlastConstant_811,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex67) ).

fof(bitBlastConstant_810,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex66) ).

fof(bitBlastConstant_809,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex65) ).

fof(bitBlastConstant_808,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex64) ).

fof(bitBlastConstant_807,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex63) ).

fof(bitBlastConstant_806,axiom,
    ~ b0000000xxxxxxxxxxxxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex49) ).

fof(addAssignment_2028,axiom,
    ! [VarCurr] :
      ( v3163(VarCurr,bitIndex49)
    <=> v3165(VarCurr,bitIndex49) ) ).

fof(addAssignment_2027,axiom,
    ! [VarCurr] :
      ( v3165(VarCurr,bitIndex49)
    <=> v3167(VarCurr,bitIndex49) ) ).

fof(addAssignment_2026,axiom,
    ! [VarCurr] :
      ( v3167(VarCurr,bitIndex49)
    <=> v3169(VarCurr,bitIndex49) ) ).

fof(addAssignment_2025,axiom,
    ! [VarCurr] :
      ( v3169(VarCurr,bitIndex49)
    <=> v3171(VarCurr,bitIndex49) ) ).

fof(addAssignment_2024,axiom,
    ! [VarCurr] :
      ( v3171(VarCurr,bitIndex49)
    <=> v3173(VarCurr,bitIndex49) ) ).

fof(addAssignment_2023,axiom,
    ! [VarCurr] :
      ( v3173(VarCurr,bitIndex49)
    <=> v3175(VarCurr,bitIndex49) ) ).

fof(addAssignment_2022,axiom,
    ! [VarCurr] :
      ( v3175(VarCurr,bitIndex49)
    <=> v8859(VarCurr,bitIndex49) ) ).

fof(addAssignment_2021,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v8859(VarCurr,B)
      <=> v8868(VarCurr,B) ) ) ).

fof(addAssignment_2020,axiom,
    ! [VarCurr] :
      ( ( v8859(VarCurr,bitIndex10)
      <=> v8866(VarCurr,bitIndex4) )
      & ( v8859(VarCurr,bitIndex9)
      <=> v8866(VarCurr,bitIndex3) )
      & ( v8859(VarCurr,bitIndex8)
      <=> v8866(VarCurr,bitIndex2) )
      & ( v8859(VarCurr,bitIndex7)
      <=> v8866(VarCurr,bitIndex1) )
      & ( v8859(VarCurr,bitIndex6)
      <=> v8866(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_2019,axiom,
    ! [VarCurr] :
      ( ( v8859(VarCurr,bitIndex44)
      <=> v8864(VarCurr,bitIndex33) )
      & ( v8859(VarCurr,bitIndex43)
      <=> v8864(VarCurr,bitIndex32) )
      & ( v8859(VarCurr,bitIndex42)
      <=> v8864(VarCurr,bitIndex31) )
      & ( v8859(VarCurr,bitIndex41)
      <=> v8864(VarCurr,bitIndex30) )
      & ( v8859(VarCurr,bitIndex40)
      <=> v8864(VarCurr,bitIndex29) )
      & ( v8859(VarCurr,bitIndex39)
      <=> v8864(VarCurr,bitIndex28) )
      & ( v8859(VarCurr,bitIndex38)
      <=> v8864(VarCurr,bitIndex27) )
      & ( v8859(VarCurr,bitIndex37)
      <=> v8864(VarCurr,bitIndex26) )
      & ( v8859(VarCurr,bitIndex36)
      <=> v8864(VarCurr,bitIndex25) )
      & ( v8859(VarCurr,bitIndex35)
      <=> v8864(VarCurr,bitIndex24) )
      & ( v8859(VarCurr,bitIndex34)
      <=> v8864(VarCurr,bitIndex23) )
      & ( v8859(VarCurr,bitIndex33)
      <=> v8864(VarCurr,bitIndex22) )
      & ( v8859(VarCurr,bitIndex32)
      <=> v8864(VarCurr,bitIndex21) )
      & ( v8859(VarCurr,bitIndex31)
      <=> v8864(VarCurr,bitIndex20) )
      & ( v8859(VarCurr,bitIndex30)
      <=> v8864(VarCurr,bitIndex19) )
      & ( v8859(VarCurr,bitIndex29)
      <=> v8864(VarCurr,bitIndex18) )
      & ( v8859(VarCurr,bitIndex28)
      <=> v8864(VarCurr,bitIndex17) )
      & ( v8859(VarCurr,bitIndex27)
      <=> v8864(VarCurr,bitIndex16) )
      & ( v8859(VarCurr,bitIndex26)
      <=> v8864(VarCurr,bitIndex15) )
      & ( v8859(VarCurr,bitIndex25)
      <=> v8864(VarCurr,bitIndex14) )
      & ( v8859(VarCurr,bitIndex24)
      <=> v8864(VarCurr,bitIndex13) )
      & ( v8859(VarCurr,bitIndex23)
      <=> v8864(VarCurr,bitIndex12) )
      & ( v8859(VarCurr,bitIndex22)
      <=> v8864(VarCurr,bitIndex11) )
      & ( v8859(VarCurr,bitIndex21)
      <=> v8864(VarCurr,bitIndex10) )
      & ( v8859(VarCurr,bitIndex20)
      <=> v8864(VarCurr,bitIndex9) )
      & ( v8859(VarCurr,bitIndex19)
      <=> v8864(VarCurr,bitIndex8) )
      & ( v8859(VarCurr,bitIndex18)
      <=> v8864(VarCurr,bitIndex7) )
      & ( v8859(VarCurr,bitIndex17)
      <=> v8864(VarCurr,bitIndex6) )
      & ( v8859(VarCurr,bitIndex16)
      <=> v8864(VarCurr,bitIndex5) )
      & ( v8859(VarCurr,bitIndex15)
      <=> v8864(VarCurr,bitIndex4) )
      & ( v8859(VarCurr,bitIndex14)
      <=> v8864(VarCurr,bitIndex3) )
      & ( v8859(VarCurr,bitIndex13)
      <=> v8864(VarCurr,bitIndex2) )
      & ( v8859(VarCurr,bitIndex12)
      <=> v8864(VarCurr,bitIndex1) )
      & ( v8859(VarCurr,bitIndex11)
      <=> v8864(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_2018,axiom,
    ! [VarCurr] :
      ( ( v8859(VarCurr,bitIndex52)
      <=> v3177(VarCurr,bitIndex7) )
      & ( v8859(VarCurr,bitIndex51)
      <=> v3177(VarCurr,bitIndex6) )
      & ( v8859(VarCurr,bitIndex50)
      <=> v3177(VarCurr,bitIndex5) )
      & ( v8859(VarCurr,bitIndex49)
      <=> v3177(VarCurr,bitIndex4) )
      & ( v8859(VarCurr,bitIndex48)
      <=> v3177(VarCurr,bitIndex3) )
      & ( v8859(VarCurr,bitIndex47)
      <=> v3177(VarCurr,bitIndex2) )
      & ( v8859(VarCurr,bitIndex46)
      <=> v3177(VarCurr,bitIndex1) )
      & ( v8859(VarCurr,bitIndex45)
      <=> v3177(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_2017,axiom,
    ! [VarCurr] :
      ( ( v8859(VarCurr,bitIndex62)
      <=> v8862(VarCurr,bitIndex9) )
      & ( v8859(VarCurr,bitIndex61)
      <=> v8862(VarCurr,bitIndex8) )
      & ( v8859(VarCurr,bitIndex60)
      <=> v8862(VarCurr,bitIndex7) )
      & ( v8859(VarCurr,bitIndex59)
      <=> v8862(VarCurr,bitIndex6) )
      & ( v8859(VarCurr,bitIndex58)
      <=> v8862(VarCurr,bitIndex5) )
      & ( v8859(VarCurr,bitIndex57)
      <=> v8862(VarCurr,bitIndex4) )
      & ( v8859(VarCurr,bitIndex56)
      <=> v8862(VarCurr,bitIndex3) )
      & ( v8859(VarCurr,bitIndex55)
      <=> v8862(VarCurr,bitIndex2) )
      & ( v8859(VarCurr,bitIndex54)
      <=> v8862(VarCurr,bitIndex1) )
      & ( v8859(VarCurr,bitIndex53)
      <=> v8862(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_2016,axiom,
    ! [VarCurr] :
      ( ( v8859(VarCurr,bitIndex69)
      <=> v8860(VarCurr,bitIndex6) )
      & ( v8859(VarCurr,bitIndex68)
      <=> v8860(VarCurr,bitIndex5) )
      & ( v8859(VarCurr,bitIndex67)
      <=> v8860(VarCurr,bitIndex4) )
      & ( v8859(VarCurr,bitIndex66)
      <=> v8860(VarCurr,bitIndex3) )
      & ( v8859(VarCurr,bitIndex65)
      <=> v8860(VarCurr,bitIndex2) )
      & ( v8859(VarCurr,bitIndex64)
      <=> v8860(VarCurr,bitIndex1) )
      & ( v8859(VarCurr,bitIndex63)
      <=> v8860(VarCurr,bitIndex0) ) ) ).

fof(addAssignmentInitValueVector_40,axiom,
    ! [B] :
      ( range_6_0(B)
     => ( v8860(constB0,B)
      <=> $false ) ) ).

fof(addAssignment_2015,axiom,
    ! [VarNext] :
      ( v3177(VarNext,bitIndex4)
    <=> v8813(VarNext,bitIndex4) ) ).

fof(addCaseBooleanConditionEqualRanges1_142,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8814(VarNext)
       => ! [B] :
            ( range_7_0(B)
           => ( v8813(VarNext,B)
            <=> v3177(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_151,axiom,
    ! [VarNext] :
      ( v8814(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v8813(VarNext,B)
          <=> v8849(VarNext,B) ) ) ) ).

fof(addAssignment_2014,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v8849(VarNext,B)
          <=> v8847(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_212,axiom,
    ! [VarCurr] :
      ( ~ v8824(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v8847(VarCurr,B)
          <=> v8850(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_204,axiom,
    ! [VarCurr] :
      ( v8824(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v8847(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_211,axiom,
    ! [VarCurr] :
      ( ~ v8827(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v8850(VarCurr,B)
          <=> v6742(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_203,axiom,
    ! [VarCurr] :
      ( v8827(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v8850(VarCurr,B)
          <=> v8851(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_210,axiom,
    ! [VarCurr] :
      ( ~ v8838(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v8851(VarCurr,B)
          <=> v8853(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_202,axiom,
    ! [VarCurr] :
      ( v8838(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v8851(VarCurr,B)
          <=> v8852(VarCurr,B) ) ) ) ).

fof(addAssignment_2013,axiom,
    ! [VarCurr] :
      ( ( v8853(VarCurr,bitIndex3)
      <=> v6553(VarCurr,bitIndex31) )
      & ( v8853(VarCurr,bitIndex2)
      <=> v6553(VarCurr,bitIndex30) )
      & ( v8853(VarCurr,bitIndex1)
      <=> v6553(VarCurr,bitIndex29) )
      & ( v8853(VarCurr,bitIndex0)
      <=> v6553(VarCurr,bitIndex28) ) ) ).

fof(addAssignment_2012,axiom,
    ! [VarCurr] :
      ( ( v8853(VarCurr,bitIndex7)
      <=> v8854(VarCurr,bitIndex3) )
      & ( v8853(VarCurr,bitIndex6)
      <=> v8854(VarCurr,bitIndex2) )
      & ( v8853(VarCurr,bitIndex5)
      <=> v8854(VarCurr,bitIndex1) )
      & ( v8853(VarCurr,bitIndex4)
      <=> v8854(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_2011,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v8854(VarCurr,B)
      <=> v8855(VarCurr,B) ) ) ).

fof(writeBinaryOperatorShiftedRanges_366,axiom,
    ! [VarCurr] :
      ( v8855(VarCurr,bitIndex0)
    <=> ( v6553(VarCurr,bitIndex32)
        | v8856(VarCurr,bitIndex0) ) ) ).

fof(writeBinaryOperatorShiftedRanges_365,axiom,
    ! [VarCurr] :
      ( v8855(VarCurr,bitIndex1)
    <=> ( v6553(VarCurr,bitIndex33)
        | v8856(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorShiftedRanges_364,axiom,
    ! [VarCurr] :
      ( v8855(VarCurr,bitIndex2)
    <=> ( v6553(VarCurr,bitIndex34)
        | v8856(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_363,axiom,
    ! [VarCurr] :
      ( v8855(VarCurr,bitIndex3)
    <=> ( v6553(VarCurr,bitIndex35)
        | v8856(VarCurr,bitIndex3) ) ) ).

fof(addAssignment_2010,axiom,
    ! [VarCurr] :
      ( v8856(VarCurr,bitIndex0)
    <=> v6553(VarCurr,bitIndex36) ) ).

fof(addAssignment_2009,axiom,
    ! [VarCurr] :
      ( ( v8856(VarCurr,bitIndex3)
      <=> $false )
      & ( v8856(VarCurr,bitIndex2)
      <=> $false )
      & ( v8856(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addAssignment_2008,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v8852(VarCurr,B)
      <=> v6742(VarCurr,B) ) ) ).

fof(addAssignment_2007,axiom,
    ! [VarCurr] :
      ( v8852(VarCurr,bitIndex4)
    <=> v8745(VarCurr) ) ).

fof(addAssignment_2006,axiom,
    ! [VarCurr,B] :
      ( range_7_5(B)
     => ( v8852(VarCurr,B)
      <=> v6742(VarCurr,B) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1665,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8814(VarNext)
      <=> ( v8815(VarNext)
          & v8822(VarNext) ) ) ) ).

fof(addAssignment_2005,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8822(VarNext)
      <=> v8820(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1664,axiom,
    ! [VarCurr] :
      ( v8820(VarCurr)
    <=> ( v8823(VarCurr)
        & v8830(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1663,axiom,
    ! [VarCurr] :
      ( v8830(VarCurr)
    <=> ( v8831(VarCurr)
        | v8824(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1662,axiom,
    ! [VarCurr] :
      ( v8831(VarCurr)
    <=> ( v8832(VarCurr)
        & v8845(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1661,axiom,
    ! [VarCurr] :
      ( v8845(VarCurr)
    <=> ( v8846(VarCurr)
        | v8828(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1660,axiom,
    ! [VarCurr] :
      ( v8846(VarCurr)
    <=> ( v8835(VarCurr)
        | v8827(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1659,axiom,
    ! [VarCurr] :
      ( v8832(VarCurr)
    <=> ( v8833(VarCurr)
        & v8843(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1658,axiom,
    ! [VarCurr] :
      ( v8843(VarCurr)
    <=> ( v56(VarCurr)
        | v8844(VarCurr) ) ) ).

fof(writeUnaryOperator_779,axiom,
    ! [VarCurr] :
      ( ~ v8844(VarCurr)
    <=> v8828(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1657,axiom,
    ! [VarCurr] :
      ( v8833(VarCurr)
    <=> ( v8834(VarCurr)
        & v8836(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1656,axiom,
    ! [VarCurr] :
      ( v8836(VarCurr)
    <=> ( v8837(VarCurr)
        | v8842(VarCurr) ) ) ).

fof(writeUnaryOperator_778,axiom,
    ! [VarCurr] :
      ( ~ v8842(VarCurr)
    <=> v8827(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1655,axiom,
    ! [VarCurr] :
      ( v8837(VarCurr)
    <=> ( v8838(VarCurr)
        | v8840(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_624,axiom,
    ! [VarCurr] :
      ( v8840(VarCurr)
    <=> ( ( v8841(VarCurr,bitIndex1)
        <=> $true )
        & ( v8841(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_2004,axiom,
    ! [VarCurr] :
      ( v8841(VarCurr,bitIndex0)
    <=> v3182(VarCurr) ) ).

fof(addAssignment_2003,axiom,
    ! [VarCurr] :
      ( v8841(VarCurr,bitIndex1)
    <=> v3180(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_623,axiom,
    ! [VarCurr] :
      ( v8838(VarCurr)
    <=> ( ( v8839(VarCurr,bitIndex1)
        <=> $true )
        & ( v8839(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_2002,axiom,
    ! [VarCurr] :
      ( v8839(VarCurr,bitIndex0)
    <=> v3182(VarCurr) ) ).

fof(addAssignment_2001,axiom,
    ! [VarCurr] :
      ( v8839(VarCurr,bitIndex1)
    <=> v3180(VarCurr) ) ).

fof(writeUnaryOperator_777,axiom,
    ! [VarCurr] :
      ( ~ v8834(VarCurr)
    <=> v8835(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_622,axiom,
    ! [VarCurr] :
      ( v8835(VarCurr)
    <=> ( ( v58(VarCurr,bitIndex2)
        <=> $false )
        & ( v58(VarCurr,bitIndex1)
        <=> $false )
        & ( v58(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1654,axiom,
    ! [VarCurr] :
      ( v8823(VarCurr)
    <=> ( v8824(VarCurr)
        | v8825(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1653,axiom,
    ! [VarCurr] :
      ( v8825(VarCurr)
    <=> ( v8826(VarCurr)
        & v8829(VarCurr) ) ) ).

fof(writeUnaryOperator_776,axiom,
    ! [VarCurr] :
      ( ~ v8829(VarCurr)
    <=> v8824(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1652,axiom,
    ! [VarCurr] :
      ( v8826(VarCurr)
    <=> ( v8827(VarCurr)
        | v8828(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_621,axiom,
    ! [VarCurr] :
      ( v8828(VarCurr)
    <=> ( ( v58(VarCurr,bitIndex2)
        <=> $false )
        & ( v58(VarCurr,bitIndex1)
        <=> $true )
        & ( v58(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_620,axiom,
    ! [VarCurr] :
      ( v8827(VarCurr)
    <=> ( ( v58(VarCurr,bitIndex2)
        <=> $false )
        & ( v58(VarCurr,bitIndex1)
        <=> $true )
        & ( v58(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeUnaryOperator_775,axiom,
    ! [VarCurr] :
      ( ~ v8824(VarCurr)
    <=> v51(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1651,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8815(VarNext)
      <=> ( v8816(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_774,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8816(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValue_109,axiom,
    ~ v3177(constB0,bitIndex4) ).

fof(bitBlastConstant_805,axiom,
    ~ bxxx0xxxx(bitIndex4) ).

fof(addAssignment_2000,axiom,
    ! [VarNext] :
      ( v6742(VarNext,bitIndex4)
    <=> v8803(VarNext,bitIndex4) ) ).

fof(addCaseBooleanConditionEqualRanges1_141,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8805(VarNext)
       => ! [B] :
            ( range_7_0(B)
           => ( v8803(VarNext,B)
            <=> v6742(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_150,axiom,
    ! [VarNext] :
      ( v8805(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v8803(VarNext,B)
          <=> v6763(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1650,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8805(VarNext)
      <=> ( v8806(VarNext)
          & v6760(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1649,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8806(VarNext)
      <=> ( v8808(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_773,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8808(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignment_1999,axiom,
    ! [VarCurr] :
      ( v6744(VarCurr,bitIndex4)
    <=> v6745(VarCurr,bitIndex4) ) ).

fof(addAssignment_1998,axiom,
    ! [VarCurr] :
      ( v4278(VarCurr,bitIndex4)
    <=> v4280(VarCurr,bitIndex4) ) ).

fof(addAssignment_1997,axiom,
    ! [VarCurr] :
      ( v4280(VarCurr,bitIndex4)
    <=> v4282(VarCurr,bitIndex4) ) ).

fof(addAssignment_1996,axiom,
    ! [VarCurr] :
      ( v4282(VarCurr,bitIndex4)
    <=> v4284(VarCurr,bitIndex28) ) ).

fof(addAssignment_1995,axiom,
    ! [VarNext] :
      ( v4284(VarNext,bitIndex28)
    <=> v8795(VarNext,bitIndex4) ) ).

fof(addCaseBooleanConditionShiftedRanges1_17,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8797(VarNext)
       => ( ( v8795(VarNext,bitIndex7)
          <=> v4284(VarCurr,bitIndex31) )
          & ( v8795(VarNext,bitIndex6)
          <=> v4284(VarCurr,bitIndex30) )
          & ( v8795(VarNext,bitIndex5)
          <=> v4284(VarCurr,bitIndex29) )
          & ( v8795(VarNext,bitIndex4)
          <=> v4284(VarCurr,bitIndex28) )
          & ( v8795(VarNext,bitIndex3)
          <=> v4284(VarCurr,bitIndex27) )
          & ( v8795(VarNext,bitIndex2)
          <=> v4284(VarCurr,bitIndex26) )
          & ( v8795(VarNext,bitIndex1)
          <=> v4284(VarCurr,bitIndex25) )
          & ( v8795(VarNext,bitIndex0)
          <=> v4284(VarCurr,bitIndex24) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_149,axiom,
    ! [VarNext] :
      ( v8797(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v8795(VarNext,B)
          <=> v4616(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1648,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8797(VarNext)
      <=> ( v8798(VarNext)
          & v4598(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1647,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8798(VarNext)
      <=> ( v8800(VarNext)
          & v2404(VarNext) ) ) ) ).

fof(writeUnaryOperator_772,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8800(VarNext)
      <=> v2411(VarNext) ) ) ).

fof(addAssignment_1994,axiom,
    ! [VarCurr] :
      ( v4582(VarCurr,bitIndex4)
    <=> v4587(VarCurr,bitIndex4) ) ).

fof(addAssignment_1993,axiom,
    ! [VarCurr] :
      ( v4586(VarCurr,bitIndex4)
    <=> v4284(VarCurr,bitIndex20) ) ).

fof(addAssignment_1992,axiom,
    ! [VarCurr] :
      ( v4575(VarCurr,bitIndex4)
    <=> v4580(VarCurr,bitIndex4) ) ).

fof(addAssignment_1991,axiom,
    ! [VarCurr] :
      ( v4579(VarCurr,bitIndex4)
    <=> v4284(VarCurr,bitIndex28) ) ).

fof(addAssignment_1990,axiom,
    ! [VarNext] :
      ( v4284(VarNext,bitIndex20)
    <=> v8787(VarNext,bitIndex4) ) ).

fof(addCaseBooleanConditionShiftedRanges1_16,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8789(VarNext)
       => ( ( v8787(VarNext,bitIndex7)
          <=> v4284(VarCurr,bitIndex23) )
          & ( v8787(VarNext,bitIndex6)
          <=> v4284(VarCurr,bitIndex22) )
          & ( v8787(VarNext,bitIndex5)
          <=> v4284(VarCurr,bitIndex21) )
          & ( v8787(VarNext,bitIndex4)
          <=> v4284(VarCurr,bitIndex20) )
          & ( v8787(VarNext,bitIndex3)
          <=> v4284(VarCurr,bitIndex19) )
          & ( v8787(VarNext,bitIndex2)
          <=> v4284(VarCurr,bitIndex18) )
          & ( v8787(VarNext,bitIndex1)
          <=> v4284(VarCurr,bitIndex17) )
          & ( v8787(VarNext,bitIndex0)
          <=> v4284(VarCurr,bitIndex16) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_148,axiom,
    ! [VarNext] :
      ( v8789(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v8787(VarNext,B)
          <=> v4570(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1646,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8789(VarNext)
      <=> ( v8790(VarNext)
          & v4552(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1645,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8790(VarNext)
      <=> ( v8792(VarNext)
          & v2404(VarNext) ) ) ) ).

fof(writeUnaryOperator_771,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8792(VarNext)
      <=> v2411(VarNext) ) ) ).

fof(addAssignment_1989,axiom,
    ! [VarCurr] :
      ( v4536(VarCurr,bitIndex4)
    <=> v4541(VarCurr,bitIndex4) ) ).

fof(addAssignment_1988,axiom,
    ! [VarCurr] :
      ( v4540(VarCurr,bitIndex4)
    <=> v4284(VarCurr,bitIndex12) ) ).

fof(addAssignment_1987,axiom,
    ! [VarCurr] :
      ( v4529(VarCurr,bitIndex4)
    <=> v4534(VarCurr,bitIndex4) ) ).

fof(addAssignment_1986,axiom,
    ! [VarCurr] :
      ( v4533(VarCurr,bitIndex4)
    <=> v4284(VarCurr,bitIndex20) ) ).

fof(addAssignment_1985,axiom,
    ! [VarCurr] :
      ( v4345(VarCurr,bitIndex4)
    <=> v4347(VarCurr,bitIndex4) ) ).

fof(addAssignment_1984,axiom,
    ! [VarCurr] :
      ( v4347(VarCurr,bitIndex4)
    <=> v3269(VarCurr,bitIndex59) ) ).

fof(addAssignment_1983,axiom,
    ! [VarCurr] :
      ( v3269(VarCurr,bitIndex59)
    <=> v3271(VarCurr,bitIndex59) ) ).

fof(addAssignment_1982,axiom,
    ! [VarCurr] :
      ( v3271(VarCurr,bitIndex59)
    <=> v3273(VarCurr,bitIndex59) ) ).

fof(addAssignment_1981,axiom,
    ! [VarCurr] :
      ( v3273(VarCurr,bitIndex59)
    <=> v3275(VarCurr,bitIndex59) ) ).

fof(addAssignment_1980,axiom,
    ! [VarCurr] :
      ( v3275(VarCurr,bitIndex59)
    <=> v3277(VarCurr,bitIndex59) ) ).

fof(addAssignment_1979,axiom,
    ! [VarCurr] :
      ( v3277(VarCurr,bitIndex59)
    <=> v3279(VarCurr,bitIndex59) ) ).

fof(addAssignment_1978,axiom,
    ! [VarCurr] :
      ( v3279(VarCurr,bitIndex59)
    <=> v3281(VarCurr,bitIndex59) ) ).

fof(addAssignment_1977,axiom,
    ! [VarCurr] :
      ( v3281(VarCurr,bitIndex59)
    <=> v4121(VarCurr,bitIndex59) ) ).

fof(addAssignment_1976,axiom,
    ! [VarNext] :
      ( v4124(VarNext,bitIndex0)
    <=> v8769(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_140,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8770(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v8769(VarNext,B)
            <=> v4124(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_147,axiom,
    ! [VarNext] :
      ( v8770(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v8769(VarNext,B)
          <=> v8783(VarNext,B) ) ) ) ).

fof(addAssignment_1975,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v8783(VarNext,B)
          <=> v8781(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_209,axiom,
    ! [VarCurr] :
      ( ~ v4113(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8781(VarCurr,B)
          <=> v8748(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_201,axiom,
    ! [VarCurr] :
      ( v4113(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8781(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1644,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8770(VarNext)
      <=> ( v8771(VarNext)
          & v8778(VarNext) ) ) ) ).

fof(addAssignment_1974,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8778(VarNext)
      <=> v8776(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1643,axiom,
    ! [VarCurr] :
      ( v8776(VarCurr)
    <=> ( v4113(VarCurr)
        | v8779(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1642,axiom,
    ! [VarCurr] :
      ( v8779(VarCurr)
    <=> ( v3287(VarCurr)
        & v8780(VarCurr) ) ) ).

fof(writeUnaryOperator_770,axiom,
    ! [VarCurr] :
      ( ~ v8780(VarCurr)
    <=> v4113(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1641,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8771(VarNext)
      <=> ( v8773(VarNext)
          & v4099(VarNext) ) ) ) ).

fof(writeUnaryOperator_769,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8773(VarNext)
      <=> v4106(VarNext) ) ) ).

fof(addAssignment_1973,axiom,
    ! [VarCurr] :
      ( v8748(VarCurr,bitIndex0)
    <=> v8750(VarCurr,bitIndex0) ) ).

fof(addAssignment_1972,axiom,
    ! [VarCurr] :
      ( v8750(VarCurr,bitIndex0)
    <=> v8751(VarCurr,bitIndex0) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_211,axiom,
    ! [VarCurr] :
      ( ~ v8752(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8751(VarCurr,B)
          <=> $false ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_214,axiom,
    ! [VarCurr] :
      ( v8752(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8751(VarCurr,B)
          <=> v8760(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges4_10,axiom,
    ! [VarCurr] :
      ( ( ~ v4411(VarCurr)
        & ~ v8761(VarCurr)
        & ~ v4439(VarCurr)
        & ~ v4442(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v8760(VarCurr,B)
          <=> $true ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_39,axiom,
    ! [VarCurr] :
      ( v4442(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8760(VarCurr,B)
          <=> v8767(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_80,axiom,
    ! [VarCurr] :
      ( v4439(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8760(VarCurr,B)
          <=> v8766(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_208,axiom,
    ! [VarCurr] :
      ( v8761(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8760(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_200,axiom,
    ! [VarCurr] :
      ( v4411(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8760(VarCurr,B)
          <=> $true ) ) ) ).

fof(addAssignment_1971,axiom,
    ! [VarCurr] :
      ( v8767(VarCurr,bitIndex0)
    <=> v4370(VarCurr,bitIndex11) ) ).

fof(addAssignment_1970,axiom,
    ! [VarCurr] :
      ( v8767(VarCurr,bitIndex1)
    <=> v4370(VarCurr,bitIndex10) ) ).

fof(addAssignment_1969,axiom,
    ! [VarCurr] :
      ( v8767(VarCurr,bitIndex2)
    <=> v4370(VarCurr,bitIndex9) ) ).

fof(addAssignment_1968,axiom,
    ! [VarCurr] :
      ( v8767(VarCurr,bitIndex3)
    <=> v4370(VarCurr,bitIndex8) ) ).

fof(addAssignment_1967,axiom,
    ! [VarCurr] :
      ( v8766(VarCurr,bitIndex0)
    <=> v4370(VarCurr,bitIndex3) ) ).

fof(addAssignment_1966,axiom,
    ! [VarCurr] :
      ( v8766(VarCurr,bitIndex1)
    <=> v4370(VarCurr,bitIndex2) ) ).

fof(addAssignment_1965,axiom,
    ! [VarCurr] :
      ( v8766(VarCurr,bitIndex2)
    <=> v4370(VarCurr,bitIndex1) ) ).

fof(addAssignment_1964,axiom,
    ! [VarCurr] :
      ( v8766(VarCurr,bitIndex3)
    <=> v4370(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1640,axiom,
    ! [VarCurr] :
      ( v8761(VarCurr)
    <=> ( v8763(VarCurr)
        | v4434(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1639,axiom,
    ! [VarCurr] :
      ( v8763(VarCurr)
    <=> ( v8764(VarCurr)
        | v4429(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1638,axiom,
    ! [VarCurr] :
      ( v8764(VarCurr)
    <=> ( v8765(VarCurr)
        | v4425(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1637,axiom,
    ! [VarCurr] :
      ( v8765(VarCurr)
    <=> ( v4413(VarCurr)
        | v4422(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1636,axiom,
    ! [VarCurr] :
      ( v8752(VarCurr)
    <=> ( v8753(VarCurr)
        | v4447(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1635,axiom,
    ! [VarCurr] :
      ( v8753(VarCurr)
    <=> ( v8754(VarCurr)
        | v4442(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1634,axiom,
    ! [VarCurr] :
      ( v8754(VarCurr)
    <=> ( v8755(VarCurr)
        | v4439(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1633,axiom,
    ! [VarCurr] :
      ( v8755(VarCurr)
    <=> ( v8756(VarCurr)
        | v4434(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1632,axiom,
    ! [VarCurr] :
      ( v8756(VarCurr)
    <=> ( v8757(VarCurr)
        | v4429(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1631,axiom,
    ! [VarCurr] :
      ( v8757(VarCurr)
    <=> ( v8758(VarCurr)
        | v4425(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1630,axiom,
    ! [VarCurr] :
      ( v8758(VarCurr)
    <=> ( v8759(VarCurr)
        | v4422(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1629,axiom,
    ! [VarCurr] :
      ( v8759(VarCurr)
    <=> ( v4411(VarCurr)
        | v4413(VarCurr) ) ) ).

fof(addAssignment_1963,axiom,
    ! [VarCurr] :
      ( v6553(VarCurr,bitIndex36)
    <=> v6555(VarCurr,bitIndex36) ) ).

fof(addAssignment_1962,axiom,
    ! [VarCurr] :
      ( v6555(VarCurr,bitIndex36)
    <=> v6557(VarCurr,bitIndex36) ) ).

fof(addAssignment_1961,axiom,
    ! [VarCurr] :
      ( v6557(VarCurr,bitIndex36)
    <=> v6559(VarCurr,bitIndex36) ) ).

fof(addAssignment_1960,axiom,
    ! [VarCurr] :
      ( v6559(VarCurr,bitIndex36)
    <=> v7082(VarCurr,bitIndex36) ) ).

fof(addAssignment_1959,axiom,
    ! [VarCurr] :
      ( v6553(VarCurr,bitIndex32)
    <=> v6555(VarCurr,bitIndex32) ) ).

fof(addAssignment_1958,axiom,
    ! [VarCurr] :
      ( v6555(VarCurr,bitIndex32)
    <=> v6557(VarCurr,bitIndex32) ) ).

fof(addAssignment_1957,axiom,
    ! [VarCurr] :
      ( v6557(VarCurr,bitIndex32)
    <=> v6559(VarCurr,bitIndex32) ) ).

fof(addAssignment_1956,axiom,
    ! [VarCurr] :
      ( v6559(VarCurr,bitIndex32)
    <=> v7082(VarCurr,bitIndex32) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1628,axiom,
    ! [VarCurr] :
      ( v8745(VarCurr)
    <=> ( v6632(VarCurr)
        | v5623(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_38,axiom,
    ! [VarCurr] :
      ( ( ~ v8711(VarCurr)
        & ~ v8712(VarCurr)
        & ~ v8743(VarCurr) )
     => ( v3180(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_79,axiom,
    ! [VarCurr] :
      ( v8743(VarCurr)
     => ( v3180(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_207,axiom,
    ! [VarCurr] :
      ( v8712(VarCurr)
     => ( v3180(VarCurr)
      <=> v8713(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_199,axiom,
    ! [VarCurr] :
      ( v8711(VarCurr)
     => ( v3180(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_619,axiom,
    ! [VarCurr] :
      ( v8743(VarCurr)
    <=> ( ( v58(VarCurr,bitIndex2)
        <=> $false )
        & ( v58(VarCurr,bitIndex1)
        <=> $true )
        & ( v58(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_206,axiom,
    ! [VarCurr] :
      ( ~ v8714(VarCurr)
     => ( v8713(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_198,axiom,
    ! [VarCurr] :
      ( v8714(VarCurr)
     => ( v8713(VarCurr)
      <=> v8715(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_618,axiom,
    ! [VarCurr] :
      ( v8742(VarCurr)
    <=> ( v2961(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_37,axiom,
    ! [VarCurr] :
      ( ( ~ v8716(VarCurr)
        & ~ v8718(VarCurr)
        & ~ v8732(VarCurr) )
     => ( v8715(VarCurr)
      <=> v8736(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_78,axiom,
    ! [VarCurr] :
      ( v8732(VarCurr)
     => ( v8715(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_205,axiom,
    ! [VarCurr] :
      ( v8718(VarCurr)
     => ( v8715(VarCurr)
      <=> v8720(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_197,axiom,
    ! [VarCurr] :
      ( v8716(VarCurr)
     => ( v8715(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_204,axiom,
    ! [VarCurr] :
      ( ~ v8737(VarCurr)
     => ( v8736(VarCurr)
      <=> v8739(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_196,axiom,
    ! [VarCurr] :
      ( v8737(VarCurr)
     => ( v8736(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_203,axiom,
    ! [VarCurr] :
      ( ~ v8740(VarCurr)
     => ( v8739(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_195,axiom,
    ! [VarCurr] :
      ( v8740(VarCurr)
     => ( v8739(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_617,axiom,
    ! [VarCurr] :
      ( v8741(VarCurr)
    <=> ( v8673(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_616,axiom,
    ! [VarCurr] :
      ( v8740(VarCurr)
    <=> ( v8673(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_615,axiom,
    ! [VarCurr] :
      ( v8738(VarCurr)
    <=> ( v5623(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_614,axiom,
    ! [VarCurr] :
      ( v8737(VarCurr)
    <=> ( v5623(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_613,axiom,
    ! [VarCurr] :
      ( v8734(VarCurr)
    <=> ( ( v8735(VarCurr,bitIndex1)
        <=> $true )
        & ( v8735(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1955,axiom,
    ! [VarCurr] :
      ( v8735(VarCurr,bitIndex0)
    <=> v8704(VarCurr) ) ).

fof(addAssignment_1954,axiom,
    ! [VarCurr] :
      ( v8735(VarCurr,bitIndex1)
    <=> v3182(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_612,axiom,
    ! [VarCurr] :
      ( v8732(VarCurr)
    <=> ( ( v8733(VarCurr,bitIndex1)
        <=> $true )
        & ( v8733(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1953,axiom,
    ! [VarCurr] :
      ( v8733(VarCurr,bitIndex0)
    <=> v8704(VarCurr) ) ).

fof(addAssignment_1952,axiom,
    ! [VarCurr] :
      ( v8733(VarCurr,bitIndex1)
    <=> v3182(VarCurr) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_202,axiom,
    ! [VarCurr] :
      ( ~ v8721(VarCurr)
     => ( v8720(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_194,axiom,
    ! [VarCurr] :
      ( v8721(VarCurr)
     => ( v8720(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1627,axiom,
    ! [VarCurr] :
      ( v8721(VarCurr)
    <=> ( v8722(VarCurr)
        | v8727(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1626,axiom,
    ! [VarCurr] :
      ( v8727(VarCurr)
    <=> ( v8728(VarCurr)
        | v8730(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_611,axiom,
    ! [VarCurr] :
      ( v8730(VarCurr)
    <=> ( ( v8731(VarCurr,bitIndex3)
        <=> $false )
        & ( v8731(VarCurr,bitIndex2)
        <=> $true )
        & ( v8731(VarCurr,bitIndex1)
        <=> $false )
        & ( v8731(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1951,axiom,
    ! [VarCurr] :
      ( v8731(VarCurr,bitIndex0)
    <=> v6632(VarCurr) ) ).

fof(addAssignment_1950,axiom,
    ! [VarCurr] :
      ( ( v8731(VarCurr,bitIndex3)
      <=> v4672(VarCurr,bitIndex2) )
      & ( v8731(VarCurr,bitIndex2)
      <=> v4672(VarCurr,bitIndex1) )
      & ( v8731(VarCurr,bitIndex1)
      <=> v4672(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_610,axiom,
    ! [VarCurr] :
      ( v8728(VarCurr)
    <=> ( ( v8729(VarCurr,bitIndex3)
        <=> $false )
        & ( v8729(VarCurr,bitIndex2)
        <=> $false )
        & ( v8729(VarCurr,bitIndex1)
        <=> $true )
        & ( v8729(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1949,axiom,
    ! [VarCurr] :
      ( v8729(VarCurr,bitIndex0)
    <=> v6632(VarCurr) ) ).

fof(addAssignment_1948,axiom,
    ! [VarCurr] :
      ( ( v8729(VarCurr,bitIndex3)
      <=> v4672(VarCurr,bitIndex2) )
      & ( v8729(VarCurr,bitIndex2)
      <=> v4672(VarCurr,bitIndex1) )
      & ( v8729(VarCurr,bitIndex1)
      <=> v4672(VarCurr,bitIndex0) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1625,axiom,
    ! [VarCurr] :
      ( v8722(VarCurr)
    <=> ( v8723(VarCurr)
        | v8725(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_609,axiom,
    ! [VarCurr] :
      ( v8725(VarCurr)
    <=> ( ( v8726(VarCurr,bitIndex3)
        <=> $false )
        & ( v8726(VarCurr,bitIndex2)
        <=> $true )
        & ( v8726(VarCurr,bitIndex1)
        <=> $false )
        & ( v8726(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1947,axiom,
    ! [VarCurr] :
      ( v8726(VarCurr,bitIndex0)
    <=> v6632(VarCurr) ) ).

fof(addAssignment_1946,axiom,
    ! [VarCurr] :
      ( ( v8726(VarCurr,bitIndex3)
      <=> v4672(VarCurr,bitIndex2) )
      & ( v8726(VarCurr,bitIndex2)
      <=> v4672(VarCurr,bitIndex1) )
      & ( v8726(VarCurr,bitIndex1)
      <=> v4672(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_608,axiom,
    ! [VarCurr] :
      ( v8723(VarCurr)
    <=> ( ( v8724(VarCurr,bitIndex3)
        <=> $false )
        & ( v8724(VarCurr,bitIndex2)
        <=> $false )
        & ( v8724(VarCurr,bitIndex1)
        <=> $true )
        & ( v8724(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1945,axiom,
    ! [VarCurr] :
      ( v8724(VarCurr,bitIndex0)
    <=> v6632(VarCurr) ) ).

fof(addAssignment_1944,axiom,
    ! [VarCurr] :
      ( ( v8724(VarCurr,bitIndex3)
      <=> v4672(VarCurr,bitIndex2) )
      & ( v8724(VarCurr,bitIndex2)
      <=> v4672(VarCurr,bitIndex1) )
      & ( v8724(VarCurr,bitIndex1)
      <=> v4672(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_607,axiom,
    ! [VarCurr] :
      ( v8718(VarCurr)
    <=> ( ( v8719(VarCurr,bitIndex1)
        <=> $false )
        & ( v8719(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1943,axiom,
    ! [VarCurr] :
      ( v8719(VarCurr,bitIndex0)
    <=> v8704(VarCurr) ) ).

fof(addAssignment_1942,axiom,
    ! [VarCurr] :
      ( v8719(VarCurr,bitIndex1)
    <=> v3182(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_606,axiom,
    ! [VarCurr] :
      ( v8716(VarCurr)
    <=> ( ( v8717(VarCurr,bitIndex1)
        <=> $false )
        & ( v8717(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1941,axiom,
    ! [VarCurr] :
      ( v8717(VarCurr,bitIndex0)
    <=> v8704(VarCurr) ) ).

fof(addAssignment_1940,axiom,
    ! [VarCurr] :
      ( v8717(VarCurr,bitIndex1)
    <=> v3182(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_605,axiom,
    ! [VarCurr] :
      ( v8714(VarCurr)
    <=> ( v2961(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_604,axiom,
    ! [VarCurr] :
      ( v8712(VarCurr)
    <=> ( ( v58(VarCurr,bitIndex2)
        <=> $false )
        & ( v58(VarCurr,bitIndex1)
        <=> $true )
        & ( v58(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_603,axiom,
    ! [VarCurr] :
      ( v8711(VarCurr)
    <=> ( ( v58(VarCurr,bitIndex2)
        <=> $false )
        & ( v58(VarCurr,bitIndex1)
        <=> $false )
        & ( v58(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignmentInitValueVector_39,axiom,
    ! [B] :
      ( range_2_0(B)
     => ( v58(constB0,B)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_36,axiom,
    ! [VarCurr] :
      ( ( ~ v8706(VarCurr)
        & ~ v5341(VarCurr)
        & ~ v5353(VarCurr) )
     => ( v8704(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_77,axiom,
    ! [VarCurr] :
      ( v5353(VarCurr)
     => ( v8704(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_201,axiom,
    ! [VarCurr] :
      ( v5341(VarCurr)
     => ( v8704(VarCurr)
      <=> v8707(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_193,axiom,
    ! [VarCurr] :
      ( v8706(VarCurr)
     => ( v8704(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_200,axiom,
    ! [VarCurr] :
      ( ~ v5343(VarCurr)
     => ( v8707(VarCurr)
      <=> v8709(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_192,axiom,
    ! [VarCurr] :
      ( v5343(VarCurr)
     => ( v8707(VarCurr)
      <=> v8708(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_199,axiom,
    ! [VarCurr] :
      ( ~ v6296(VarCurr)
     => ( v8709(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_191,axiom,
    ! [VarCurr] :
      ( v6296(VarCurr)
     => ( v8709(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_76,axiom,
    ! [VarCurr] :
      ( ( ~ v5345(VarCurr)
        & ~ v5347(VarCurr) )
     => ( v8708(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_198,axiom,
    ! [VarCurr] :
      ( v5347(VarCurr)
     => ( v8708(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_190,axiom,
    ! [VarCurr] :
      ( v5345(VarCurr)
     => ( v8708(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1624,axiom,
    ! [VarCurr] :
      ( v8706(VarCurr)
    <=> ( v5337(VarCurr)
        | v5340(VarCurr) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_139,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8688(VarNext)
       => ( v3182(VarNext)
        <=> v3182(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_146,axiom,
    ! [VarNext] :
      ( v8688(VarNext)
     => ( v3182(VarNext)
      <=> v8696(VarNext) ) ) ).

fof(addAssignment_1939,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8696(VarNext)
      <=> v8694(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_210,axiom,
    ! [VarCurr] :
      ( ~ v8697(VarCurr)
     => ( v8694(VarCurr)
      <=> v8698(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_213,axiom,
    ! [VarCurr] :
      ( v8697(VarCurr)
     => ( v8694(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_209,axiom,
    ! [VarCurr] :
      ( ~ v3184(VarCurr)
     => ( v8698(VarCurr)
      <=> v8699(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_212,axiom,
    ! [VarCurr] :
      ( v3184(VarCurr)
     => ( v8698(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1623,axiom,
    ! [VarCurr] :
      ( v8699(VarCurr)
    <=> ( v8700(VarCurr)
        & v3182(VarCurr) ) ) ).

fof(writeUnaryOperator_768,axiom,
    ! [VarCurr] :
      ( ~ v8700(VarCurr)
    <=> v8673(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_602,axiom,
    ! [VarCurr] :
      ( v8697(VarCurr)
    <=> ( v51(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1622,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8688(VarNext)
      <=> v8689(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1621,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8689(VarNext)
      <=> ( v8690(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_767,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8690(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges5_6,axiom,
    ! [VarCurr] :
      ( ( ~ v5338(VarCurr)
        & ~ v5339(VarCurr)
        & ~ v5340(VarCurr)
        & ~ v5341(VarCurr)
        & ~ v5353(VarCurr) )
     => ( v8673(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges4_9,axiom,
    ! [VarCurr] :
      ( v5353(VarCurr)
     => ( v8673(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_35,axiom,
    ! [VarCurr] :
      ( v5341(VarCurr)
     => ( v8673(VarCurr)
      <=> v8677(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_75,axiom,
    ! [VarCurr] :
      ( v5340(VarCurr)
     => ( v8673(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_197,axiom,
    ! [VarCurr] :
      ( v5339(VarCurr)
     => ( v8673(VarCurr)
      <=> v8675(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_189,axiom,
    ! [VarCurr] :
      ( v5338(VarCurr)
     => ( v8673(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_196,axiom,
    ! [VarCurr] :
      ( ~ v5343(VarCurr)
     => ( v8677(VarCurr)
      <=> v8685(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_188,axiom,
    ! [VarCurr] :
      ( v5343(VarCurr)
     => ( v8677(VarCurr)
      <=> v8678(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_195,axiom,
    ! [VarCurr] :
      ( ~ v6296(VarCurr)
     => ( v8685(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_187,axiom,
    ! [VarCurr] :
      ( v6296(VarCurr)
     => ( v8685(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_74,axiom,
    ! [VarCurr] :
      ( ( ~ v5345(VarCurr)
        & ~ v5347(VarCurr) )
     => ( v8678(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_194,axiom,
    ! [VarCurr] :
      ( v5347(VarCurr)
     => ( v8678(VarCurr)
      <=> v8682(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_186,axiom,
    ! [VarCurr] :
      ( v5345(VarCurr)
     => ( v8678(VarCurr)
      <=> v8679(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_193,axiom,
    ! [VarCurr] :
      ( ~ v8683(VarCurr)
     => ( v8682(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_185,axiom,
    ! [VarCurr] :
      ( v8683(VarCurr)
     => ( v8682(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_601,axiom,
    ! [VarCurr] :
      ( v8684(VarCurr)
    <=> ( v5327(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_600,axiom,
    ! [VarCurr] :
      ( v8683(VarCurr)
    <=> ( v5327(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_192,axiom,
    ! [VarCurr] :
      ( ~ v8680(VarCurr)
     => ( v8679(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_184,axiom,
    ! [VarCurr] :
      ( v8680(VarCurr)
     => ( v8679(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_599,axiom,
    ! [VarCurr] :
      ( v8681(VarCurr)
    <=> ( v6632(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_598,axiom,
    ! [VarCurr] :
      ( v8680(VarCurr)
    <=> ( v6632(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_191,axiom,
    ! [VarCurr] :
      ( ~ v6292(VarCurr)
     => ( v8675(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_183,axiom,
    ! [VarCurr] :
      ( v6292(VarCurr)
     => ( v8675(VarCurr)
      <=> v8676(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_190,axiom,
    ! [VarCurr] :
      ( ~ v7731(VarCurr)
     => ( v8676(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_182,axiom,
    ! [VarCurr] :
      ( v7731(VarCurr)
     => ( v8676(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges5_5,axiom,
    ! [VarCurr] :
      ( ( ~ v5338(VarCurr)
        & ~ v5339(VarCurr)
        & ~ v5340(VarCurr)
        & ~ v5341(VarCurr)
        & ~ v5353(VarCurr) )
     => ( v3184(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges4_8,axiom,
    ! [VarCurr] :
      ( v5353(VarCurr)
     => ( v3184(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_34,axiom,
    ! [VarCurr] :
      ( v5341(VarCurr)
     => ( v3184(VarCurr)
      <=> v8668(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_73,axiom,
    ! [VarCurr] :
      ( v5340(VarCurr)
     => ( v3184(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_189,axiom,
    ! [VarCurr] :
      ( v5339(VarCurr)
     => ( v3184(VarCurr)
      <=> v8666(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_181,axiom,
    ! [VarCurr] :
      ( v5338(VarCurr)
     => ( v3184(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_188,axiom,
    ! [VarCurr] :
      ( ~ v5343(VarCurr)
     => ( v8668(VarCurr)
      <=> v8671(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_180,axiom,
    ! [VarCurr] :
      ( v5343(VarCurr)
     => ( v8668(VarCurr)
      <=> v8669(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_187,axiom,
    ! [VarCurr] :
      ( ~ v6296(VarCurr)
     => ( v8671(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_179,axiom,
    ! [VarCurr] :
      ( v6296(VarCurr)
     => ( v8671(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_186,axiom,
    ! [VarCurr] :
      ( ~ v8670(VarCurr)
     => ( v8669(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_178,axiom,
    ! [VarCurr] :
      ( v8670(VarCurr)
     => ( v8669(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1620,axiom,
    ! [VarCurr] :
      ( v8670(VarCurr)
    <=> ( v5345(VarCurr)
        | v5347(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_185,axiom,
    ! [VarCurr] :
      ( ~ v6292(VarCurr)
     => ( v8666(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_177,axiom,
    ! [VarCurr] :
      ( v6292(VarCurr)
     => ( v8666(VarCurr)
      <=> v8667(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_184,axiom,
    ! [VarCurr] :
      ( ~ v7731(VarCurr)
     => ( v8667(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_176,axiom,
    ! [VarCurr] :
      ( v7731(VarCurr)
     => ( v8667(VarCurr)
      <=> $false ) ) ).

fof(addCaseBooleanConditionEqualRanges1_138,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8653(VarNext)
       => ! [B] :
            ( range_2_0(B)
           => ( v3186(VarNext,B)
            <=> v3186(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_145,axiom,
    ! [VarNext] :
      ( v8653(VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v3186(VarNext,B)
          <=> v8661(VarNext,B) ) ) ) ).

fof(addAssignment_1938,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v8661(VarNext,B)
          <=> v8659(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_208,axiom,
    ! [VarCurr] :
      ( ~ v8662(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8659(VarCurr,B)
          <=> v3188(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_211,axiom,
    ! [VarCurr] :
      ( v8662(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8659(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_597,axiom,
    ! [VarCurr] :
      ( v8662(VarCurr)
    <=> ( v51(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1619,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8653(VarNext)
      <=> v8654(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1618,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8654(VarNext)
      <=> ( v8655(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_766,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8655(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges5_4,axiom,
    ! [VarCurr] :
      ( ( ~ v8620(VarCurr)
        & ~ v8624(VarCurr)
        & ~ v8629(VarCurr)
        & ~ v8633(VarCurr)
        & ~ v8650(VarCurr) )
     => ! [B] :
          ( range_2_0(B)
         => ( v3188(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges4_7,axiom,
    ! [VarCurr] :
      ( v8650(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v3188(VarCurr,B)
          <=> b001(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_33,axiom,
    ! [VarCurr] :
      ( v8633(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v3188(VarCurr,B)
          <=> v8634(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_72,axiom,
    ! [VarCurr] :
      ( v8629(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v3188(VarCurr,B)
          <=> v8630(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_183,axiom,
    ! [VarCurr] :
      ( v8624(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v3188(VarCurr,B)
          <=> v8625(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_175,axiom,
    ! [VarCurr] :
      ( v8620(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v3188(VarCurr,B)
          <=> v8621(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_596,axiom,
    ! [VarCurr] :
      ( v8650(VarCurr)
    <=> ( ( v3186(VarCurr,bitIndex2)
        <=> $true )
        & ( v3186(VarCurr,bitIndex1)
        <=> $false )
        & ( v3186(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_182,axiom,
    ! [VarCurr] :
      ( ~ v8635(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8634(VarCurr,B)
          <=> v8644(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_174,axiom,
    ! [VarCurr] :
      ( v8635(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8634(VarCurr,B)
          <=> v8636(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_181,axiom,
    ! [VarCurr] :
      ( ~ v8645(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8644(VarCurr,B)
          <=> v8647(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_173,axiom,
    ! [VarCurr] :
      ( v8645(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8644(VarCurr,B)
          <=> b001(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_180,axiom,
    ! [VarCurr] :
      ( ~ v8648(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8647(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_172,axiom,
    ! [VarCurr] :
      ( v8648(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8647(VarCurr,B)
          <=> b001(B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_595,axiom,
    ! [VarCurr] :
      ( v8649(VarCurr)
    <=> ( v3190(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_594,axiom,
    ! [VarCurr] :
      ( v8648(VarCurr)
    <=> ( v3190(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_593,axiom,
    ! [VarCurr] :
      ( v8646(VarCurr)
    <=> ( v5280(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_592,axiom,
    ! [VarCurr] :
      ( v8645(VarCurr)
    <=> ( v5280(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_591,axiom,
    ! [VarCurr] :
      ( v8643(VarCurr)
    <=> ( v3182(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_71,axiom,
    ! [VarCurr] :
      ( ( ~ v8637(VarCurr)
        & ~ v8640(VarCurr) )
     => ! [B] :
          ( range_2_0(B)
         => ( v8636(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_179,axiom,
    ! [VarCurr] :
      ( v8640(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8636(VarCurr,B)
          <=> v8642(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_171,axiom,
    ! [VarCurr] :
      ( v8637(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8636(VarCurr,B)
          <=> v8639(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_207,axiom,
    ! [VarCurr] :
      ( ~ v5327(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8642(VarCurr,B)
          <=> b011(B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_210,axiom,
    ! [VarCurr] :
      ( v5327(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8642(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_590,axiom,
    ! [VarCurr] :
      ( v8640(VarCurr)
    <=> ( ( v8641(VarCurr,bitIndex1)
        <=> $true )
        & ( v8641(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1937,axiom,
    ! [VarCurr] :
      ( v8641(VarCurr,bitIndex0)
    <=> v4697(VarCurr) ) ).

fof(addAssignment_1936,axiom,
    ! [VarCurr] :
      ( v8641(VarCurr,bitIndex1)
    <=> v4670(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_206,axiom,
    ! [VarCurr] :
      ( ~ v6632(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8639(VarCurr,B)
          <=> b100(B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_209,axiom,
    ! [VarCurr] :
      ( v6632(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8639(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_589,axiom,
    ! [VarCurr] :
      ( v8637(VarCurr)
    <=> ( ( v8638(VarCurr,bitIndex1)
        <=> $false )
        & ( v8638(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1935,axiom,
    ! [VarCurr] :
      ( v8638(VarCurr,bitIndex0)
    <=> v4697(VarCurr) ) ).

fof(addAssignment_1934,axiom,
    ! [VarCurr] :
      ( v8638(VarCurr,bitIndex1)
    <=> v4670(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_588,axiom,
    ! [VarCurr] :
      ( v8635(VarCurr)
    <=> ( v3182(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_587,axiom,
    ! [VarCurr] :
      ( v8633(VarCurr)
    <=> ( ( v3186(VarCurr,bitIndex2)
        <=> $false )
        & ( v3186(VarCurr,bitIndex1)
        <=> $true )
        & ( v3186(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_178,axiom,
    ! [VarCurr] :
      ( ~ v8631(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8630(VarCurr,B)
          <=> b011(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_170,axiom,
    ! [VarCurr] :
      ( v8631(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8630(VarCurr,B)
          <=> b010(B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_586,axiom,
    ! [VarCurr] :
      ( v8632(VarCurr)
    <=> ( v2961(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_585,axiom,
    ! [VarCurr] :
      ( v8631(VarCurr)
    <=> ( v2961(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_584,axiom,
    ! [VarCurr] :
      ( v8629(VarCurr)
    <=> ( ( v3186(VarCurr,bitIndex2)
        <=> $false )
        & ( v3186(VarCurr,bitIndex1)
        <=> $true )
        & ( v3186(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_177,axiom,
    ! [VarCurr] :
      ( ~ v8626(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8625(VarCurr,B)
          <=> b010(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_169,axiom,
    ! [VarCurr] :
      ( v8626(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8625(VarCurr,B)
          <=> v8627(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_583,axiom,
    ! [VarCurr] :
      ( v8628(VarCurr)
    <=> ( v3182(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_205,axiom,
    ! [VarCurr] :
      ( ~ v5623(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8627(VarCurr,B)
          <=> b010(B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_208,axiom,
    ! [VarCurr] :
      ( v5623(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8627(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_582,axiom,
    ! [VarCurr] :
      ( v8626(VarCurr)
    <=> ( v3182(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_581,axiom,
    ! [VarCurr] :
      ( v8624(VarCurr)
    <=> ( ( v3186(VarCurr,bitIndex2)
        <=> $false )
        & ( v3186(VarCurr,bitIndex1)
        <=> $false )
        & ( v3186(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_176,axiom,
    ! [VarCurr] :
      ( ~ v8622(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8621(VarCurr,B)
          <=> b001(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_168,axiom,
    ! [VarCurr] :
      ( v8622(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v8621(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_580,axiom,
    ! [VarCurr] :
      ( v8623(VarCurr)
    <=> ( v3190(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_579,axiom,
    ! [VarCurr] :
      ( v8622(VarCurr)
    <=> ( v3190(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_578,axiom,
    ! [VarCurr] :
      ( v8620(VarCurr)
    <=> ( ( v3186(VarCurr,bitIndex2)
        <=> $false )
        & ( v3186(VarCurr,bitIndex1)
        <=> $false )
        & ( v3186(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1617,axiom,
    ! [VarCurr] :
      ( v3190(VarCurr)
    <=> ( v3192(VarCurr)
        | v4666(VarCurr) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_137,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8604(VarNext)
       => ( v4666(VarNext)
        <=> v4666(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_144,axiom,
    ! [VarNext] :
      ( v8604(VarNext)
     => ( v4666(VarNext)
      <=> v8612(VarNext) ) ) ).

fof(addAssignment_1933,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8612(VarNext)
      <=> v8610(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_204,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ( v8610(VarCurr)
      <=> v8613(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_207,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ( v8610(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_203,axiom,
    ! [VarCurr] :
      ( ~ v3192(VarCurr)
     => ( v8613(VarCurr)
      <=> v8614(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_206,axiom,
    ! [VarCurr] :
      ( v3192(VarCurr)
     => ( v8613(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1616,axiom,
    ! [VarCurr] :
      ( v8614(VarCurr)
    <=> ( v8615(VarCurr)
        & v4666(VarCurr) ) ) ).

fof(writeUnaryOperator_765,axiom,
    ! [VarCurr] :
      ( ~ v8615(VarCurr)
    <=> v4668(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1615,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8604(VarNext)
      <=> v8605(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1614,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8605(VarNext)
      <=> ( v8607(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_764,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8607(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_32,axiom,
    ! [VarCurr] :
      ( ( ~ v8598(VarCurr)
        & ~ v5341(VarCurr)
        & ~ v5353(VarCurr) )
     => ( v4668(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_70,axiom,
    ! [VarCurr] :
      ( v5353(VarCurr)
     => ( v4668(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_175,axiom,
    ! [VarCurr] :
      ( v5341(VarCurr)
     => ( v4668(VarCurr)
      <=> v8599(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_167,axiom,
    ! [VarCurr] :
      ( v8598(VarCurr)
     => ( v4668(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_174,axiom,
    ! [VarCurr] :
      ( ~ v5343(VarCurr)
     => ( v8599(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_166,axiom,
    ! [VarCurr] :
      ( v5343(VarCurr)
     => ( v8599(VarCurr)
      <=> v8600(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_173,axiom,
    ! [VarCurr] :
      ( ~ v8601(VarCurr)
     => ( v8600(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_165,axiom,
    ! [VarCurr] :
      ( v8601(VarCurr)
     => ( v8600(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1613,axiom,
    ! [VarCurr] :
      ( v8601(VarCurr)
    <=> ( v5345(VarCurr)
        | v5347(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1612,axiom,
    ! [VarCurr] :
      ( v8598(VarCurr)
    <=> ( v5337(VarCurr)
        | v5340(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_202,axiom,
    ! [VarCurr] :
      ( ~ v8467(VarCurr)
     => ( v4670(VarCurr)
      <=> v8594(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_205,axiom,
    ! [VarCurr] :
      ( v8467(VarCurr)
     => ( v4670(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_172,axiom,
    ! [VarCurr] :
      ( ~ v8469(VarCurr)
     => ( v8594(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_164,axiom,
    ! [VarCurr] :
      ( v8469(VarCurr)
     => ( v8594(VarCurr)
      <=> v8595(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_201,axiom,
    ! [VarCurr] :
      ( ~ v8475(VarCurr)
     => ( v8595(VarCurr)
      <=> v8596(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_204,axiom,
    ! [VarCurr] :
      ( v8475(VarCurr)
     => ( v8595(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_200,axiom,
    ! [VarCurr] :
      ( ~ v8477(VarCurr)
     => ( v8596(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_203,axiom,
    ! [VarCurr] :
      ( v8477(VarCurr)
     => ( v8596(VarCurr)
      <=> $false ) ) ).

fof(addCaseBooleanConditionEqualRanges1_136,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8582(VarNext)
       => ( v4693(VarNext)
        <=> v4693(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_143,axiom,
    ! [VarNext] :
      ( v8582(VarNext)
     => ( v4693(VarNext)
      <=> v8590(VarNext) ) ) ).

fof(addAssignment_1932,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8590(VarNext)
      <=> v8588(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_199,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ( v8588(VarCurr)
      <=> v4695(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_202,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ( v8588(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1611,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8582(VarNext)
      <=> v8583(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1610,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8583(VarNext)
      <=> ( v8585(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_763,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8585(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges4_6,axiom,
    ! [VarCurr] :
      ( ( ~ v5338(VarCurr)
        & ~ v8575(VarCurr)
        & ~ v5341(VarCurr)
        & ~ v5353(VarCurr) )
     => ( v4695(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_31,axiom,
    ! [VarCurr] :
      ( v5353(VarCurr)
     => ( v4695(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_69,axiom,
    ! [VarCurr] :
      ( v5341(VarCurr)
     => ( v4695(VarCurr)
      <=> v8577(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_171,axiom,
    ! [VarCurr] :
      ( v8575(VarCurr)
     => ( v4695(VarCurr)
      <=> v8576(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_163,axiom,
    ! [VarCurr] :
      ( v5338(VarCurr)
     => ( v4695(VarCurr)
      <=> v8572(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_170,axiom,
    ! [VarCurr] :
      ( ~ v5343(VarCurr)
     => ( v8577(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_162,axiom,
    ! [VarCurr] :
      ( v5343(VarCurr)
     => ( v8577(VarCurr)
      <=> v8578(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_169,axiom,
    ! [VarCurr] :
      ( ~ v8579(VarCurr)
     => ( v8578(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_161,axiom,
    ! [VarCurr] :
      ( v8579(VarCurr)
     => ( v8578(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1609,axiom,
    ! [VarCurr] :
      ( v8579(VarCurr)
    <=> ( v5345(VarCurr)
        | v5347(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_168,axiom,
    ! [VarCurr] :
      ( ~ v6292(VarCurr)
     => ( v8576(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_160,axiom,
    ! [VarCurr] :
      ( v6292(VarCurr)
     => ( v8576(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1608,axiom,
    ! [VarCurr] :
      ( v8575(VarCurr)
    <=> ( v5339(VarCurr)
        | v5340(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_167,axiom,
    ! [VarCurr] :
      ( ~ v8573(VarCurr)
     => ( v8572(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_159,axiom,
    ! [VarCurr] :
      ( v8573(VarCurr)
     => ( v8572(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_577,axiom,
    ! [VarCurr] :
      ( v8574(VarCurr)
    <=> ( v3190(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_576,axiom,
    ! [VarCurr] :
      ( v8573(VarCurr)
    <=> ( v3190(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_198,axiom,
    ! [VarCurr] :
      ( ~ v8467(VarCurr)
     => ( v4697(VarCurr)
      <=> v8468(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_201,axiom,
    ! [VarCurr] :
      ( v8467(VarCurr)
     => ( v4697(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_166,axiom,
    ! [VarCurr] :
      ( ~ v8469(VarCurr)
     => ( v8468(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_158,axiom,
    ! [VarCurr] :
      ( v8469(VarCurr)
     => ( v8468(VarCurr)
      <=> v8474(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_197,axiom,
    ! [VarCurr] :
      ( ~ v8475(VarCurr)
     => ( v8474(VarCurr)
      <=> v8476(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_200,axiom,
    ! [VarCurr] :
      ( v8475(VarCurr)
     => ( v8474(VarCurr)
      <=> $true ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_196,axiom,
    ! [VarCurr] :
      ( ~ v8477(VarCurr)
     => ( v8476(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_199,axiom,
    ! [VarCurr] :
      ( v8477(VarCurr)
     => ( v8476(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1607,axiom,
    ! [VarCurr] :
      ( v8477(VarCurr)
    <=> ( v8478(VarCurr)
        & v8513(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_575,axiom,
    ! [VarCurr] :
      ( v8513(VarCurr)
    <=> ( v8514(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges31_1,axiom,
    ! [VarCurr] :
      ( ( ~ v8539(VarCurr)
        & ~ v8540(VarCurr)
        & ~ v8541(VarCurr)
        & ~ v8542(VarCurr)
        & ~ v8543(VarCurr)
        & ~ v8544(VarCurr)
        & ~ v8545(VarCurr)
        & ~ v8546(VarCurr)
        & ~ v8547(VarCurr)
        & ~ v8548(VarCurr)
        & ~ v8549(VarCurr)
        & ~ v8550(VarCurr)
        & ~ v8551(VarCurr)
        & ~ v8552(VarCurr)
        & ~ v8553(VarCurr)
        & ~ v8554(VarCurr)
        & ~ v8555(VarCurr)
        & ~ v8556(VarCurr)
        & ~ v8557(VarCurr)
        & ~ v8558(VarCurr)
        & ~ v8559(VarCurr)
        & ~ v8560(VarCurr)
        & ~ v8561(VarCurr)
        & ~ v8562(VarCurr)
        & ~ v8563(VarCurr)
        & ~ v8564(VarCurr)
        & ~ v8565(VarCurr)
        & ~ v8566(VarCurr)
        & ~ v8567(VarCurr)
        & ~ v8568(VarCurr)
        & ~ v8569(VarCurr) )
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex31) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges30_1,axiom,
    ! [VarCurr] :
      ( v8569(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex30) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges29_1,axiom,
    ! [VarCurr] :
      ( v8568(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex29) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges28_1,axiom,
    ! [VarCurr] :
      ( v8567(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex28) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges27_1,axiom,
    ! [VarCurr] :
      ( v8566(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex27) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges26_1,axiom,
    ! [VarCurr] :
      ( v8565(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex26) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges25_1,axiom,
    ! [VarCurr] :
      ( v8564(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex25) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges24_1,axiom,
    ! [VarCurr] :
      ( v8563(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex24) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges23_1,axiom,
    ! [VarCurr] :
      ( v8562(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex23) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges22_1,axiom,
    ! [VarCurr] :
      ( v8561(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex22) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges21_1,axiom,
    ! [VarCurr] :
      ( v8560(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex21) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges20_1,axiom,
    ! [VarCurr] :
      ( v8559(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex20) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges19_1,axiom,
    ! [VarCurr] :
      ( v8558(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex19) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges18_1,axiom,
    ! [VarCurr] :
      ( v8557(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex18) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges17_1,axiom,
    ! [VarCurr] :
      ( v8556(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex17) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges16_1,axiom,
    ! [VarCurr] :
      ( v8555(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex16) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges15_1,axiom,
    ! [VarCurr] :
      ( v8554(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex15) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges14_1,axiom,
    ! [VarCurr] :
      ( v8553(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex14) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges13_1,axiom,
    ! [VarCurr] :
      ( v8552(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex13) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges12_1,axiom,
    ! [VarCurr] :
      ( v8551(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex12) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges11_1,axiom,
    ! [VarCurr] :
      ( v8550(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex11) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges10_1,axiom,
    ! [VarCurr] :
      ( v8549(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex10) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges9_1,axiom,
    ! [VarCurr] :
      ( v8548(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex9) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges8_1,axiom,
    ! [VarCurr] :
      ( v8547(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex8) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges7_1,axiom,
    ! [VarCurr] :
      ( v8546(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex7) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges6_1,axiom,
    ! [VarCurr] :
      ( v8545(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex6) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges5_1,axiom,
    ! [VarCurr] :
      ( v8544(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex5) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges4_1,axiom,
    ! [VarCurr] :
      ( v8543(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex4) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges3_1,axiom,
    ! [VarCurr] :
      ( v8542(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex3) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges2_1,axiom,
    ! [VarCurr] :
      ( v8541(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex2) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges1_1,axiom,
    ! [VarCurr] :
      ( v8540(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex1) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_157,axiom,
    ! [VarCurr] :
      ( v8539(VarCurr)
     => ( v8514(VarCurr)
      <=> v4923(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_574,axiom,
    ! [VarCurr] :
      ( v8570(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_573,axiom,
    ! [VarCurr] :
      ( v8569(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_572,axiom,
    ! [VarCurr] :
      ( v8568(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_571,axiom,
    ! [VarCurr] :
      ( v8567(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_570,axiom,
    ! [VarCurr] :
      ( v8566(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_569,axiom,
    ! [VarCurr] :
      ( v8565(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_568,axiom,
    ! [VarCurr] :
      ( v8564(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_567,axiom,
    ! [VarCurr] :
      ( v8563(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_566,axiom,
    ! [VarCurr] :
      ( v8562(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_565,axiom,
    ! [VarCurr] :
      ( v8561(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_564,axiom,
    ! [VarCurr] :
      ( v8560(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_563,axiom,
    ! [VarCurr] :
      ( v8559(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_562,axiom,
    ! [VarCurr] :
      ( v8558(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_561,axiom,
    ! [VarCurr] :
      ( v8557(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_560,axiom,
    ! [VarCurr] :
      ( v8556(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_559,axiom,
    ! [VarCurr] :
      ( v8555(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $true )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_558,axiom,
    ! [VarCurr] :
      ( v8554(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_557,axiom,
    ! [VarCurr] :
      ( v8553(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_556,axiom,
    ! [VarCurr] :
      ( v8552(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_555,axiom,
    ! [VarCurr] :
      ( v8551(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_554,axiom,
    ! [VarCurr] :
      ( v8550(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_553,axiom,
    ! [VarCurr] :
      ( v8549(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_552,axiom,
    ! [VarCurr] :
      ( v8548(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_551,axiom,
    ! [VarCurr] :
      ( v8547(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $true )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_550,axiom,
    ! [VarCurr] :
      ( v8546(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_549,axiom,
    ! [VarCurr] :
      ( v8545(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_548,axiom,
    ! [VarCurr] :
      ( v8544(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_547,axiom,
    ! [VarCurr] :
      ( v8543(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $true )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_546,axiom,
    ! [VarCurr] :
      ( v8542(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_545,axiom,
    ! [VarCurr] :
      ( v8541(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $true )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_544,axiom,
    ! [VarCurr] :
      ( v8540(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_543,axiom,
    ! [VarCurr] :
      ( v8539(VarCurr)
    <=> ( ( v8516(VarCurr,bitIndex4)
        <=> $false )
        & ( v8516(VarCurr,bitIndex3)
        <=> $false )
        & ( v8516(VarCurr,bitIndex2)
        <=> $false )
        & ( v8516(VarCurr,bitIndex1)
        <=> $false )
        & ( v8516(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1931,axiom,
    ! [VarCurr] :
      ( v8516(VarCurr,bitIndex0)
    <=> v7869(VarCurr) ) ).

fof(addAssignment_1930,axiom,
    ! [VarCurr] :
      ( v8516(VarCurr,bitIndex1)
    <=> v8536(VarCurr) ) ).

fof(addAssignment_1929,axiom,
    ! [VarCurr] :
      ( v8516(VarCurr,bitIndex2)
    <=> v8532(VarCurr) ) ).

fof(addAssignment_1928,axiom,
    ! [VarCurr] :
      ( v8516(VarCurr,bitIndex3)
    <=> v8528(VarCurr) ) ).

fof(addAssignment_1927,axiom,
    ! [VarCurr] :
      ( v8516(VarCurr,bitIndex4)
    <=> v8518(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1606,axiom,
    ! [VarCurr] :
      ( v8536(VarCurr)
    <=> ( v8537(VarCurr)
        & v8538(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1605,axiom,
    ! [VarCurr] :
      ( v8538(VarCurr)
    <=> ( v4699(VarCurr,bitIndex0)
        | v7829(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_362,axiom,
    ! [VarCurr] :
      ( v8537(VarCurr)
    <=> ( v7869(VarCurr)
        | v4699(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1604,axiom,
    ! [VarCurr] :
      ( v8532(VarCurr)
    <=> ( v8533(VarCurr)
        & v8535(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1603,axiom,
    ! [VarCurr] :
      ( v8535(VarCurr)
    <=> ( v7835(VarCurr)
        | v8525(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_361,axiom,
    ! [VarCurr] :
      ( v8533(VarCurr)
    <=> ( v4699(VarCurr,bitIndex2)
        | v8534(VarCurr) ) ) ).

fof(writeUnaryOperator_762,axiom,
    ! [VarCurr] :
      ( ~ v8534(VarCurr)
    <=> v8525(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1602,axiom,
    ! [VarCurr] :
      ( v8528(VarCurr)
    <=> ( v8529(VarCurr)
        & v8531(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1601,axiom,
    ! [VarCurr] :
      ( v8531(VarCurr)
    <=> ( v7841(VarCurr)
        | v8523(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_360,axiom,
    ! [VarCurr] :
      ( v8529(VarCurr)
    <=> ( v4699(VarCurr,bitIndex3)
        | v8530(VarCurr) ) ) ).

fof(writeUnaryOperator_761,axiom,
    ! [VarCurr] :
      ( ~ v8530(VarCurr)
    <=> v8523(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1600,axiom,
    ! [VarCurr] :
      ( v8518(VarCurr)
    <=> ( v8519(VarCurr)
        & v8527(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1599,axiom,
    ! [VarCurr] :
      ( v8527(VarCurr)
    <=> ( v7848(VarCurr)
        | v8521(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_359,axiom,
    ! [VarCurr] :
      ( v8519(VarCurr)
    <=> ( v4699(VarCurr,bitIndex4)
        | v8520(VarCurr) ) ) ).

fof(writeUnaryOperator_760,axiom,
    ! [VarCurr] :
      ( ~ v8520(VarCurr)
    <=> v8521(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_358,axiom,
    ! [VarCurr] :
      ( v8521(VarCurr)
    <=> ( v4699(VarCurr,bitIndex3)
        | v8522(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1598,axiom,
    ! [VarCurr] :
      ( v8522(VarCurr)
    <=> ( v7841(VarCurr)
        & v8523(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_357,axiom,
    ! [VarCurr] :
      ( v8523(VarCurr)
    <=> ( v4699(VarCurr,bitIndex2)
        | v8524(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1597,axiom,
    ! [VarCurr] :
      ( v8524(VarCurr)
    <=> ( v7835(VarCurr)
        & v8525(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_356,axiom,
    ! [VarCurr] :
      ( v8525(VarCurr)
    <=> ( v4699(VarCurr,bitIndex1)
        | v8526(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1596,axiom,
    ! [VarCurr] :
      ( v8526(VarCurr)
    <=> ( v4699(VarCurr,bitIndex0)
        & v7829(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_542,axiom,
    ! [VarCurr] :
      ( v8478(VarCurr)
    <=> ( v8479(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges31,axiom,
    ! [VarCurr] :
      ( ( ~ v8481(VarCurr)
        & ~ v8482(VarCurr)
        & ~ v8483(VarCurr)
        & ~ v8484(VarCurr)
        & ~ v8485(VarCurr)
        & ~ v8486(VarCurr)
        & ~ v8487(VarCurr)
        & ~ v8488(VarCurr)
        & ~ v8489(VarCurr)
        & ~ v8490(VarCurr)
        & ~ v8491(VarCurr)
        & ~ v8492(VarCurr)
        & ~ v8493(VarCurr)
        & ~ v8494(VarCurr)
        & ~ v8495(VarCurr)
        & ~ v8496(VarCurr)
        & ~ v8497(VarCurr)
        & ~ v8498(VarCurr)
        & ~ v8499(VarCurr)
        & ~ v8500(VarCurr)
        & ~ v8501(VarCurr)
        & ~ v8502(VarCurr)
        & ~ v8503(VarCurr)
        & ~ v8504(VarCurr)
        & ~ v8505(VarCurr)
        & ~ v8506(VarCurr)
        & ~ v8507(VarCurr)
        & ~ v8508(VarCurr)
        & ~ v8509(VarCurr)
        & ~ v8510(VarCurr)
        & ~ v8511(VarCurr) )
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex31) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges30,axiom,
    ! [VarCurr] :
      ( v8511(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex30) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges29,axiom,
    ! [VarCurr] :
      ( v8510(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex29) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges28,axiom,
    ! [VarCurr] :
      ( v8509(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex28) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges27,axiom,
    ! [VarCurr] :
      ( v8508(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex27) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges26,axiom,
    ! [VarCurr] :
      ( v8507(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex26) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges25,axiom,
    ! [VarCurr] :
      ( v8506(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex25) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges24,axiom,
    ! [VarCurr] :
      ( v8505(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex24) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges23,axiom,
    ! [VarCurr] :
      ( v8504(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex23) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges22,axiom,
    ! [VarCurr] :
      ( v8503(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex22) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges21,axiom,
    ! [VarCurr] :
      ( v8502(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex21) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges20,axiom,
    ! [VarCurr] :
      ( v8501(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex20) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges19,axiom,
    ! [VarCurr] :
      ( v8500(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex19) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges18,axiom,
    ! [VarCurr] :
      ( v8499(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex18) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges17,axiom,
    ! [VarCurr] :
      ( v8498(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex17) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges16,axiom,
    ! [VarCurr] :
      ( v8497(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex16) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges15,axiom,
    ! [VarCurr] :
      ( v8496(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex15) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges14,axiom,
    ! [VarCurr] :
      ( v8495(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex14) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges13,axiom,
    ! [VarCurr] :
      ( v8494(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex13) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges12,axiom,
    ! [VarCurr] :
      ( v8493(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex12) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges11,axiom,
    ! [VarCurr] :
      ( v8492(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex11) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges10,axiom,
    ! [VarCurr] :
      ( v8491(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex10) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges9,axiom,
    ! [VarCurr] :
      ( v8490(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex9) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges8,axiom,
    ! [VarCurr] :
      ( v8489(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex8) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges7,axiom,
    ! [VarCurr] :
      ( v8488(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex7) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges6,axiom,
    ! [VarCurr] :
      ( v8487(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex6) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges5,axiom,
    ! [VarCurr] :
      ( v8486(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex5) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges4,axiom,
    ! [VarCurr] :
      ( v8485(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex4) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges3,axiom,
    ! [VarCurr] :
      ( v8484(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex3) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges2,axiom,
    ! [VarCurr] :
      ( v8483(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex2) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges1,axiom,
    ! [VarCurr] :
      ( v8482(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex1) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_156,axiom,
    ! [VarCurr] :
      ( v8481(VarCurr)
     => ( v8479(VarCurr)
      <=> v4923(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_541,axiom,
    ! [VarCurr] :
      ( v8512(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_540,axiom,
    ! [VarCurr] :
      ( v8511(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_539,axiom,
    ! [VarCurr] :
      ( v8510(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_538,axiom,
    ! [VarCurr] :
      ( v8509(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_537,axiom,
    ! [VarCurr] :
      ( v8508(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_536,axiom,
    ! [VarCurr] :
      ( v8507(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_535,axiom,
    ! [VarCurr] :
      ( v8506(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_534,axiom,
    ! [VarCurr] :
      ( v8505(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_533,axiom,
    ! [VarCurr] :
      ( v8504(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_532,axiom,
    ! [VarCurr] :
      ( v8503(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_531,axiom,
    ! [VarCurr] :
      ( v8502(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_530,axiom,
    ! [VarCurr] :
      ( v8501(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_529,axiom,
    ! [VarCurr] :
      ( v8500(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_528,axiom,
    ! [VarCurr] :
      ( v8499(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_527,axiom,
    ! [VarCurr] :
      ( v8498(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_526,axiom,
    ! [VarCurr] :
      ( v8497(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_525,axiom,
    ! [VarCurr] :
      ( v8496(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_524,axiom,
    ! [VarCurr] :
      ( v8495(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_523,axiom,
    ! [VarCurr] :
      ( v8494(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_522,axiom,
    ! [VarCurr] :
      ( v8493(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_521,axiom,
    ! [VarCurr] :
      ( v8492(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_520,axiom,
    ! [VarCurr] :
      ( v8491(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_519,axiom,
    ! [VarCurr] :
      ( v8490(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_518,axiom,
    ! [VarCurr] :
      ( v8489(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_517,axiom,
    ! [VarCurr] :
      ( v8488(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_516,axiom,
    ! [VarCurr] :
      ( v8487(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_515,axiom,
    ! [VarCurr] :
      ( v8486(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_514,axiom,
    ! [VarCurr] :
      ( v8485(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_513,axiom,
    ! [VarCurr] :
      ( v8484(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_512,axiom,
    ! [VarCurr] :
      ( v8483(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_511,axiom,
    ! [VarCurr] :
      ( v8482(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_510,axiom,
    ! [VarCurr] :
      ( v8481(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_509,axiom,
    ! [VarCurr] :
      ( v8475(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1595,axiom,
    ! [VarCurr] :
      ( v8469(VarCurr)
    <=> ( v8470(VarCurr)
        | v8472(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_508,axiom,
    ! [VarCurr] :
      ( v8472(VarCurr)
    <=> ( ( v8473(VarCurr,bitIndex3)
        <=> $false )
        & ( v8473(VarCurr,bitIndex2)
        <=> $true )
        & ( v8473(VarCurr,bitIndex1)
        <=> $false )
        & ( v8473(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1926,axiom,
    ! [VarCurr] :
      ( v8473(VarCurr,bitIndex0)
    <=> v4693(VarCurr) ) ).

fof(addAssignment_1925,axiom,
    ! [VarCurr] :
      ( ( v8473(VarCurr,bitIndex3)
      <=> v4672(VarCurr,bitIndex2) )
      & ( v8473(VarCurr,bitIndex2)
      <=> v4672(VarCurr,bitIndex1) )
      & ( v8473(VarCurr,bitIndex1)
      <=> v4672(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_507,axiom,
    ! [VarCurr] :
      ( v8470(VarCurr)
    <=> ( ( v8471(VarCurr,bitIndex3)
        <=> $false )
        & ( v8471(VarCurr,bitIndex2)
        <=> $false )
        & ( v8471(VarCurr,bitIndex1)
        <=> $true )
        & ( v8471(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1924,axiom,
    ! [VarCurr] :
      ( v8471(VarCurr,bitIndex0)
    <=> v4693(VarCurr) ) ).

fof(addAssignment_1923,axiom,
    ! [VarCurr] :
      ( ( v8471(VarCurr,bitIndex3)
      <=> v4672(VarCurr,bitIndex2) )
      & ( v8471(VarCurr,bitIndex2)
      <=> v4672(VarCurr,bitIndex1) )
      & ( v8471(VarCurr,bitIndex1)
      <=> v4672(VarCurr,bitIndex0) ) ) ).

fof(addAssignmentInitValueVector_38,axiom,
    ( v4693(constB0)
  <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_506,axiom,
    ! [VarCurr] :
      ( v8467(VarCurr)
    <=> ( v51(VarCurr)
      <=> $false ) ) ).

fof(addAssignment_1922,axiom,
    ! [VarCurr] :
      ( v4925(VarCurr,bitIndex0)
    <=> v4927(VarCurr,bitIndex0) ) ).

fof(addAssignment_1921,axiom,
    ! [VarCurr] :
      ( v4927(VarCurr,bitIndex0)
    <=> v4929(VarCurr,bitIndex0) ) ).

fof(addAssignment_1920,axiom,
    ! [VarCurr] :
      ( v4929(VarCurr,bitIndex0)
    <=> v4931(VarCurr,bitIndex0) ) ).

fof(addAssignment_1919,axiom,
    ! [VarCurr] :
      ( v4931(VarCurr,bitIndex0)
    <=> v6529(VarCurr,bitIndex0) ) ).

fof(addAssignment_1918,axiom,
    ! [VarCurr] :
      ( v5270(VarCurr)
    <=> v5272(VarCurr) ) ).

fof(addAssignment_1917,axiom,
    ! [VarCurr] :
      ( v5272(VarCurr)
    <=> v5274(VarCurr) ) ).

fof(addAssignment_1916,axiom,
    ! [VarCurr] :
      ( v5274(VarCurr)
    <=> v5276(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_135,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8455(VarNext)
       => ( v5276(VarNext)
        <=> v5276(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_142,axiom,
    ! [VarNext] :
      ( v8455(VarNext)
     => ( v5276(VarNext)
      <=> v8463(VarNext) ) ) ).

fof(addAssignment_1915,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8463(VarNext)
      <=> v8461(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_195,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ( v8461(VarCurr)
      <=> v5278(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_198,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ( v8461(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1594,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8455(VarNext)
      <=> v8456(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1593,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8456(VarNext)
      <=> ( v8458(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_759,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8458(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValueVector_37,axiom,
    ( v5276(constB0)
  <=> $false ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_30,axiom,
    ! [VarCurr] :
      ( ( ~ v8449(VarCurr)
        & ~ v5341(VarCurr)
        & ~ v5353(VarCurr) )
     => ( v5278(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_68,axiom,
    ! [VarCurr] :
      ( v5353(VarCurr)
     => ( v5278(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_165,axiom,
    ! [VarCurr] :
      ( v5341(VarCurr)
     => ( v5278(VarCurr)
      <=> v8450(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_155,axiom,
    ! [VarCurr] :
      ( v8449(VarCurr)
     => ( v5278(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_164,axiom,
    ! [VarCurr] :
      ( ~ v5343(VarCurr)
     => ( v8450(VarCurr)
      <=> v8452(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_154,axiom,
    ! [VarCurr] :
      ( v5343(VarCurr)
     => ( v8450(VarCurr)
      <=> v8451(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_163,axiom,
    ! [VarCurr] :
      ( ~ v6296(VarCurr)
     => ( v8452(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_153,axiom,
    ! [VarCurr] :
      ( v6296(VarCurr)
     => ( v8452(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_67,axiom,
    ! [VarCurr] :
      ( ( ~ v5345(VarCurr)
        & ~ v5347(VarCurr) )
     => ( v8451(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_162,axiom,
    ! [VarCurr] :
      ( v5347(VarCurr)
     => ( v8451(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_152,axiom,
    ! [VarCurr] :
      ( v5345(VarCurr)
     => ( v8451(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1592,axiom,
    ! [VarCurr] :
      ( v8449(VarCurr)
    <=> ( v5337(VarCurr)
        | v5340(VarCurr) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_134,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8437(VarNext)
       => ( v5280(VarNext)
        <=> v5280(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_141,axiom,
    ! [VarNext] :
      ( v8437(VarNext)
     => ( v5280(VarNext)
      <=> v8445(VarNext) ) ) ).

fof(addAssignment_1914,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8445(VarNext)
      <=> v8443(VarCurr) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_108,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ( v8443(VarCurr)
      <=> v5282(VarCurr,bitIndex4) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_197,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ( v8443(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1591,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8437(VarNext)
      <=> v8438(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1590,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8438(VarNext)
      <=> ( v8440(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_758,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8440(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignment_1913,axiom,
    ! [VarCurr] :
      ( v5282(VarCurr,bitIndex4)
    <=> v5284(VarCurr,bitIndex4) ) ).

fof(addAssignment_1912,axiom,
    ! [VarCurr] :
      ( v5284(VarCurr,bitIndex4)
    <=> v5286(VarCurr,bitIndex4) ) ).

fof(addAssignment_1911,axiom,
    ! [VarCurr] :
      ( v5286(VarCurr,bitIndex4)
    <=> v5288(VarCurr,bitIndex4) ) ).

fof(addAssignment_1910,axiom,
    ! [VarCurr] :
      ( v5288(VarCurr,bitIndex4)
    <=> v7873(VarCurr,bitIndex4) ) ).

fof(memoryReadIntoBuffer_87,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00000_address_term = A
             => ( range_4_0(B)
               => ( v8143(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_86,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00001_address_term = A
             => ( range_4_0(B)
               => ( v8152(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_85,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00010_address_term = A
             => ( range_4_0(B)
               => ( v8161(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_84,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00011_address_term = A
             => ( range_4_0(B)
               => ( v8170(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_83,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00100_address_term = A
             => ( range_4_0(B)
               => ( v8179(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_82,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00101_address_term = A
             => ( range_4_0(B)
               => ( v8188(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_81,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00110_address_term = A
             => ( range_4_0(B)
               => ( v8197(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_80,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00111_address_term = A
             => ( range_4_0(B)
               => ( v8206(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_79,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01000_address_term = A
             => ( range_4_0(B)
               => ( v8215(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_78,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01001_address_term = A
             => ( range_4_0(B)
               => ( v8224(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_77,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01010_address_term = A
             => ( range_4_0(B)
               => ( v8233(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_76,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01011_address_term = A
             => ( range_4_0(B)
               => ( v8242(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_75,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01100_address_term = A
             => ( range_4_0(B)
               => ( v8251(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_74,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01101_address_term = A
             => ( range_4_0(B)
               => ( v8260(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_73,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01110_address_term = A
             => ( range_4_0(B)
               => ( v8269(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_72,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01111_address_term = A
             => ( range_4_0(B)
               => ( v8278(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_71,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10000_address_term = A
             => ( range_4_0(B)
               => ( v8287(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_70,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10001_address_term = A
             => ( range_4_0(B)
               => ( v8296(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_69,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10010_address_term = A
             => ( range_4_0(B)
               => ( v8305(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_68,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10011_address_term = A
             => ( range_4_0(B)
               => ( v8314(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_67,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10100_address_term = A
             => ( range_4_0(B)
               => ( v8323(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_66,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10101_address_term = A
             => ( range_4_0(B)
               => ( v8332(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_65,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10110_address_term = A
             => ( range_4_0(B)
               => ( v8341(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_64,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10111_address_term = A
             => ( range_4_0(B)
               => ( v8350(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_63,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11000_address_term = A
             => ( range_4_0(B)
               => ( v8359(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_62,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11001_address_term = A
             => ( range_4_0(B)
               => ( v8368(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_61,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11010_address_term = A
             => ( range_4_0(B)
               => ( v8377(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_60,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11011_address_term = A
             => ( range_4_0(B)
               => ( v8386(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_59,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11100_address_term = A
             => ( range_4_0(B)
               => ( v8395(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_58,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11101_address_term = A
             => ( range_4_0(B)
               => ( v8404(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_57,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11110_address_term = A
             => ( range_4_0(B)
               => ( v8413(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_56,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11111_address_term = A
             => ( range_4_0(B)
               => ( v8422(VarNext,B)
                <=> v5290_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_55,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v7750_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( address(A)
             => ! [B] :
                  ( A = AssociatedAddressVar
                 => ( range_4_0(B)
                   => ( v7873(VarNext,B)
                    <=> v5290_array(VarNext,A,B) ) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_54,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v5575_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( address(A)
             => ! [B] :
                  ( A = AssociatedAddressVar
                 => ( range_4_0(B)
                   => ( v8433(VarNext,B)
                    <=> v5290_array(VarNext,A,B) ) ) ) ) ) ) ).

fof(memoryConstantWriteDisabled_5,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( $true
              & v8425(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_array(VarNext,A,B)
              <=> v5290_36__array(VarNext,A,B) ) ) ) ) ).

fof(memoryConstantWriteEnabledInsideRange_5,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( $true
            & v8425(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_array(VarNext,A,B)
              <=> b00000(B) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1589,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8425(VarNext)
      <=> ( v8426(VarNext)
          & v8431(VarNext) ) ) ) ).

fof(addAssignment_1909,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8431(VarNext)
      <=> v8096(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1588,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8426(VarNext)
      <=> ( v8428(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_757,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8428(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_91,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11111_address_term = A
              & v8416(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_36__array(VarNext,A,B)
              <=> v5290_35__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_91,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11111_address_term = A
            & v8416(VarNext) )
         => ( ( v5290_36__array(VarNext,A,bitIndex4)
            <=> v8422(VarNext,bitIndex159) )
            & ( v5290_36__array(VarNext,A,bitIndex3)
            <=> v8422(VarNext,bitIndex158) )
            & ( v5290_36__array(VarNext,A,bitIndex2)
            <=> v8422(VarNext,bitIndex157) )
            & ( v5290_36__array(VarNext,A,bitIndex1)
            <=> v8422(VarNext,bitIndex156) )
            & ( v5290_36__array(VarNext,A,bitIndex0)
            <=> v8422(VarNext,bitIndex155) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1587,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8416(VarNext)
      <=> ( v8417(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1586,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8417(VarNext)
      <=> ( v8419(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_756,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8419(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_90,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11110_address_term = A
              & v8407(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_35__array(VarNext,A,B)
              <=> v5290_34__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_90,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11110_address_term = A
            & v8407(VarNext) )
         => ( ( v5290_35__array(VarNext,A,bitIndex4)
            <=> v8413(VarNext,bitIndex154) )
            & ( v5290_35__array(VarNext,A,bitIndex3)
            <=> v8413(VarNext,bitIndex153) )
            & ( v5290_35__array(VarNext,A,bitIndex2)
            <=> v8413(VarNext,bitIndex152) )
            & ( v5290_35__array(VarNext,A,bitIndex1)
            <=> v8413(VarNext,bitIndex151) )
            & ( v5290_35__array(VarNext,A,bitIndex0)
            <=> v8413(VarNext,bitIndex150) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1585,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8407(VarNext)
      <=> ( v8408(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1584,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8408(VarNext)
      <=> ( v8410(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_755,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8410(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_89,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11101_address_term = A
              & v8398(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_34__array(VarNext,A,B)
              <=> v5290_33__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_89,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11101_address_term = A
            & v8398(VarNext) )
         => ( ( v5290_34__array(VarNext,A,bitIndex4)
            <=> v8404(VarNext,bitIndex149) )
            & ( v5290_34__array(VarNext,A,bitIndex3)
            <=> v8404(VarNext,bitIndex148) )
            & ( v5290_34__array(VarNext,A,bitIndex2)
            <=> v8404(VarNext,bitIndex147) )
            & ( v5290_34__array(VarNext,A,bitIndex1)
            <=> v8404(VarNext,bitIndex146) )
            & ( v5290_34__array(VarNext,A,bitIndex0)
            <=> v8404(VarNext,bitIndex145) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1583,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8398(VarNext)
      <=> ( v8399(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1582,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8399(VarNext)
      <=> ( v8401(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_754,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8401(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_88,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11100_address_term = A
              & v8389(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_33__array(VarNext,A,B)
              <=> v5290_32__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_88,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11100_address_term = A
            & v8389(VarNext) )
         => ( ( v5290_33__array(VarNext,A,bitIndex4)
            <=> v8395(VarNext,bitIndex144) )
            & ( v5290_33__array(VarNext,A,bitIndex3)
            <=> v8395(VarNext,bitIndex143) )
            & ( v5290_33__array(VarNext,A,bitIndex2)
            <=> v8395(VarNext,bitIndex142) )
            & ( v5290_33__array(VarNext,A,bitIndex1)
            <=> v8395(VarNext,bitIndex141) )
            & ( v5290_33__array(VarNext,A,bitIndex0)
            <=> v8395(VarNext,bitIndex140) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1581,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8389(VarNext)
      <=> ( v8390(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1580,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8390(VarNext)
      <=> ( v8392(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_753,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8392(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_87,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11011_address_term = A
              & v8380(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_32__array(VarNext,A,B)
              <=> v5290_31__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_87,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11011_address_term = A
            & v8380(VarNext) )
         => ( ( v5290_32__array(VarNext,A,bitIndex4)
            <=> v8386(VarNext,bitIndex139) )
            & ( v5290_32__array(VarNext,A,bitIndex3)
            <=> v8386(VarNext,bitIndex138) )
            & ( v5290_32__array(VarNext,A,bitIndex2)
            <=> v8386(VarNext,bitIndex137) )
            & ( v5290_32__array(VarNext,A,bitIndex1)
            <=> v8386(VarNext,bitIndex136) )
            & ( v5290_32__array(VarNext,A,bitIndex0)
            <=> v8386(VarNext,bitIndex135) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1579,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8380(VarNext)
      <=> ( v8381(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1578,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8381(VarNext)
      <=> ( v8383(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_752,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8383(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_86,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11010_address_term = A
              & v8371(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_31__array(VarNext,A,B)
              <=> v5290_30__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_86,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11010_address_term = A
            & v8371(VarNext) )
         => ( ( v5290_31__array(VarNext,A,bitIndex4)
            <=> v8377(VarNext,bitIndex134) )
            & ( v5290_31__array(VarNext,A,bitIndex3)
            <=> v8377(VarNext,bitIndex133) )
            & ( v5290_31__array(VarNext,A,bitIndex2)
            <=> v8377(VarNext,bitIndex132) )
            & ( v5290_31__array(VarNext,A,bitIndex1)
            <=> v8377(VarNext,bitIndex131) )
            & ( v5290_31__array(VarNext,A,bitIndex0)
            <=> v8377(VarNext,bitIndex130) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1577,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8371(VarNext)
      <=> ( v8372(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1576,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8372(VarNext)
      <=> ( v8374(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_751,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8374(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_85,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11001_address_term = A
              & v8362(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_30__array(VarNext,A,B)
              <=> v5290_29__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_85,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11001_address_term = A
            & v8362(VarNext) )
         => ( ( v5290_30__array(VarNext,A,bitIndex4)
            <=> v8368(VarNext,bitIndex129) )
            & ( v5290_30__array(VarNext,A,bitIndex3)
            <=> v8368(VarNext,bitIndex128) )
            & ( v5290_30__array(VarNext,A,bitIndex2)
            <=> v8368(VarNext,bitIndex127) )
            & ( v5290_30__array(VarNext,A,bitIndex1)
            <=> v8368(VarNext,bitIndex126) )
            & ( v5290_30__array(VarNext,A,bitIndex0)
            <=> v8368(VarNext,bitIndex125) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1575,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8362(VarNext)
      <=> ( v8363(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1574,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8363(VarNext)
      <=> ( v8365(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_750,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8365(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_84,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11000_address_term = A
              & v8353(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_29__array(VarNext,A,B)
              <=> v5290_28__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_84,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11000_address_term = A
            & v8353(VarNext) )
         => ( ( v5290_29__array(VarNext,A,bitIndex4)
            <=> v8359(VarNext,bitIndex124) )
            & ( v5290_29__array(VarNext,A,bitIndex3)
            <=> v8359(VarNext,bitIndex123) )
            & ( v5290_29__array(VarNext,A,bitIndex2)
            <=> v8359(VarNext,bitIndex122) )
            & ( v5290_29__array(VarNext,A,bitIndex1)
            <=> v8359(VarNext,bitIndex121) )
            & ( v5290_29__array(VarNext,A,bitIndex0)
            <=> v8359(VarNext,bitIndex120) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1573,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8353(VarNext)
      <=> ( v8354(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1572,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8354(VarNext)
      <=> ( v8356(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_749,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8356(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_83,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10111_address_term = A
              & v8344(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_28__array(VarNext,A,B)
              <=> v5290_27__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_83,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10111_address_term = A
            & v8344(VarNext) )
         => ( ( v5290_28__array(VarNext,A,bitIndex4)
            <=> v8350(VarNext,bitIndex119) )
            & ( v5290_28__array(VarNext,A,bitIndex3)
            <=> v8350(VarNext,bitIndex118) )
            & ( v5290_28__array(VarNext,A,bitIndex2)
            <=> v8350(VarNext,bitIndex117) )
            & ( v5290_28__array(VarNext,A,bitIndex1)
            <=> v8350(VarNext,bitIndex116) )
            & ( v5290_28__array(VarNext,A,bitIndex0)
            <=> v8350(VarNext,bitIndex115) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1571,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8344(VarNext)
      <=> ( v8345(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1570,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8345(VarNext)
      <=> ( v8347(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_748,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8347(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_82,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10110_address_term = A
              & v8335(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_27__array(VarNext,A,B)
              <=> v5290_26__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_82,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10110_address_term = A
            & v8335(VarNext) )
         => ( ( v5290_27__array(VarNext,A,bitIndex4)
            <=> v8341(VarNext,bitIndex114) )
            & ( v5290_27__array(VarNext,A,bitIndex3)
            <=> v8341(VarNext,bitIndex113) )
            & ( v5290_27__array(VarNext,A,bitIndex2)
            <=> v8341(VarNext,bitIndex112) )
            & ( v5290_27__array(VarNext,A,bitIndex1)
            <=> v8341(VarNext,bitIndex111) )
            & ( v5290_27__array(VarNext,A,bitIndex0)
            <=> v8341(VarNext,bitIndex110) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1569,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8335(VarNext)
      <=> ( v8336(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1568,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8336(VarNext)
      <=> ( v8338(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_747,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8338(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_81,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10101_address_term = A
              & v8326(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_26__array(VarNext,A,B)
              <=> v5290_25__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_81,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10101_address_term = A
            & v8326(VarNext) )
         => ( ( v5290_26__array(VarNext,A,bitIndex4)
            <=> v8332(VarNext,bitIndex109) )
            & ( v5290_26__array(VarNext,A,bitIndex3)
            <=> v8332(VarNext,bitIndex108) )
            & ( v5290_26__array(VarNext,A,bitIndex2)
            <=> v8332(VarNext,bitIndex107) )
            & ( v5290_26__array(VarNext,A,bitIndex1)
            <=> v8332(VarNext,bitIndex106) )
            & ( v5290_26__array(VarNext,A,bitIndex0)
            <=> v8332(VarNext,bitIndex105) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1567,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8326(VarNext)
      <=> ( v8327(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1566,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8327(VarNext)
      <=> ( v8329(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_746,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8329(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_80,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10100_address_term = A
              & v8317(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_25__array(VarNext,A,B)
              <=> v5290_24__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_80,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10100_address_term = A
            & v8317(VarNext) )
         => ( ( v5290_25__array(VarNext,A,bitIndex4)
            <=> v8323(VarNext,bitIndex104) )
            & ( v5290_25__array(VarNext,A,bitIndex3)
            <=> v8323(VarNext,bitIndex103) )
            & ( v5290_25__array(VarNext,A,bitIndex2)
            <=> v8323(VarNext,bitIndex102) )
            & ( v5290_25__array(VarNext,A,bitIndex1)
            <=> v8323(VarNext,bitIndex101) )
            & ( v5290_25__array(VarNext,A,bitIndex0)
            <=> v8323(VarNext,bitIndex100) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1565,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8317(VarNext)
      <=> ( v8318(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1564,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8318(VarNext)
      <=> ( v8320(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_745,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8320(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_79,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10011_address_term = A
              & v8308(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_24__array(VarNext,A,B)
              <=> v5290_23__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_79,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10011_address_term = A
            & v8308(VarNext) )
         => ( ( v5290_24__array(VarNext,A,bitIndex4)
            <=> v8314(VarNext,bitIndex99) )
            & ( v5290_24__array(VarNext,A,bitIndex3)
            <=> v8314(VarNext,bitIndex98) )
            & ( v5290_24__array(VarNext,A,bitIndex2)
            <=> v8314(VarNext,bitIndex97) )
            & ( v5290_24__array(VarNext,A,bitIndex1)
            <=> v8314(VarNext,bitIndex96) )
            & ( v5290_24__array(VarNext,A,bitIndex0)
            <=> v8314(VarNext,bitIndex95) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1563,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8308(VarNext)
      <=> ( v8309(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1562,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8309(VarNext)
      <=> ( v8311(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_744,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8311(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_78,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10010_address_term = A
              & v8299(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_23__array(VarNext,A,B)
              <=> v5290_22__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_78,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10010_address_term = A
            & v8299(VarNext) )
         => ( ( v5290_23__array(VarNext,A,bitIndex4)
            <=> v8305(VarNext,bitIndex94) )
            & ( v5290_23__array(VarNext,A,bitIndex3)
            <=> v8305(VarNext,bitIndex93) )
            & ( v5290_23__array(VarNext,A,bitIndex2)
            <=> v8305(VarNext,bitIndex92) )
            & ( v5290_23__array(VarNext,A,bitIndex1)
            <=> v8305(VarNext,bitIndex91) )
            & ( v5290_23__array(VarNext,A,bitIndex0)
            <=> v8305(VarNext,bitIndex90) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1561,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8299(VarNext)
      <=> ( v8300(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1560,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8300(VarNext)
      <=> ( v8302(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_743,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8302(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_77,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10001_address_term = A
              & v8290(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_22__array(VarNext,A,B)
              <=> v5290_21__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_77,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10001_address_term = A
            & v8290(VarNext) )
         => ( ( v5290_22__array(VarNext,A,bitIndex4)
            <=> v8296(VarNext,bitIndex89) )
            & ( v5290_22__array(VarNext,A,bitIndex3)
            <=> v8296(VarNext,bitIndex88) )
            & ( v5290_22__array(VarNext,A,bitIndex2)
            <=> v8296(VarNext,bitIndex87) )
            & ( v5290_22__array(VarNext,A,bitIndex1)
            <=> v8296(VarNext,bitIndex86) )
            & ( v5290_22__array(VarNext,A,bitIndex0)
            <=> v8296(VarNext,bitIndex85) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1559,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8290(VarNext)
      <=> ( v8291(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1558,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8291(VarNext)
      <=> ( v8293(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_742,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8293(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_76,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10000_address_term = A
              & v8281(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_21__array(VarNext,A,B)
              <=> v5290_20__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_76,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10000_address_term = A
            & v8281(VarNext) )
         => ( ( v5290_21__array(VarNext,A,bitIndex4)
            <=> v8287(VarNext,bitIndex84) )
            & ( v5290_21__array(VarNext,A,bitIndex3)
            <=> v8287(VarNext,bitIndex83) )
            & ( v5290_21__array(VarNext,A,bitIndex2)
            <=> v8287(VarNext,bitIndex82) )
            & ( v5290_21__array(VarNext,A,bitIndex1)
            <=> v8287(VarNext,bitIndex81) )
            & ( v5290_21__array(VarNext,A,bitIndex0)
            <=> v8287(VarNext,bitIndex80) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1557,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8281(VarNext)
      <=> ( v8282(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1556,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8282(VarNext)
      <=> ( v8284(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_741,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8284(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_75,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01111_address_term = A
              & v8272(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_20__array(VarNext,A,B)
              <=> v5290_19__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_75,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01111_address_term = A
            & v8272(VarNext) )
         => ( ( v5290_20__array(VarNext,A,bitIndex4)
            <=> v8278(VarNext,bitIndex79) )
            & ( v5290_20__array(VarNext,A,bitIndex3)
            <=> v8278(VarNext,bitIndex78) )
            & ( v5290_20__array(VarNext,A,bitIndex2)
            <=> v8278(VarNext,bitIndex77) )
            & ( v5290_20__array(VarNext,A,bitIndex1)
            <=> v8278(VarNext,bitIndex76) )
            & ( v5290_20__array(VarNext,A,bitIndex0)
            <=> v8278(VarNext,bitIndex75) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1555,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8272(VarNext)
      <=> ( v8273(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1554,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8273(VarNext)
      <=> ( v8275(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_740,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8275(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_74,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01110_address_term = A
              & v8263(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_19__array(VarNext,A,B)
              <=> v5290_18__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_74,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01110_address_term = A
            & v8263(VarNext) )
         => ( ( v5290_19__array(VarNext,A,bitIndex4)
            <=> v8269(VarNext,bitIndex74) )
            & ( v5290_19__array(VarNext,A,bitIndex3)
            <=> v8269(VarNext,bitIndex73) )
            & ( v5290_19__array(VarNext,A,bitIndex2)
            <=> v8269(VarNext,bitIndex72) )
            & ( v5290_19__array(VarNext,A,bitIndex1)
            <=> v8269(VarNext,bitIndex71) )
            & ( v5290_19__array(VarNext,A,bitIndex0)
            <=> v8269(VarNext,bitIndex70) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1553,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8263(VarNext)
      <=> ( v8264(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1552,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8264(VarNext)
      <=> ( v8266(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_739,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8266(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_73,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01101_address_term = A
              & v8254(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_18__array(VarNext,A,B)
              <=> v5290_17__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_73,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01101_address_term = A
            & v8254(VarNext) )
         => ( ( v5290_18__array(VarNext,A,bitIndex4)
            <=> v8260(VarNext,bitIndex69) )
            & ( v5290_18__array(VarNext,A,bitIndex3)
            <=> v8260(VarNext,bitIndex68) )
            & ( v5290_18__array(VarNext,A,bitIndex2)
            <=> v8260(VarNext,bitIndex67) )
            & ( v5290_18__array(VarNext,A,bitIndex1)
            <=> v8260(VarNext,bitIndex66) )
            & ( v5290_18__array(VarNext,A,bitIndex0)
            <=> v8260(VarNext,bitIndex65) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1551,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8254(VarNext)
      <=> ( v8255(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1550,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8255(VarNext)
      <=> ( v8257(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_738,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8257(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_72,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01100_address_term = A
              & v8245(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_17__array(VarNext,A,B)
              <=> v5290_16__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_72,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01100_address_term = A
            & v8245(VarNext) )
         => ( ( v5290_17__array(VarNext,A,bitIndex4)
            <=> v8251(VarNext,bitIndex64) )
            & ( v5290_17__array(VarNext,A,bitIndex3)
            <=> v8251(VarNext,bitIndex63) )
            & ( v5290_17__array(VarNext,A,bitIndex2)
            <=> v8251(VarNext,bitIndex62) )
            & ( v5290_17__array(VarNext,A,bitIndex1)
            <=> v8251(VarNext,bitIndex61) )
            & ( v5290_17__array(VarNext,A,bitIndex0)
            <=> v8251(VarNext,bitIndex60) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1549,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8245(VarNext)
      <=> ( v8246(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1548,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8246(VarNext)
      <=> ( v8248(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_737,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8248(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_71,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01011_address_term = A
              & v8236(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_16__array(VarNext,A,B)
              <=> v5290_15__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_71,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01011_address_term = A
            & v8236(VarNext) )
         => ( ( v5290_16__array(VarNext,A,bitIndex4)
            <=> v8242(VarNext,bitIndex59) )
            & ( v5290_16__array(VarNext,A,bitIndex3)
            <=> v8242(VarNext,bitIndex58) )
            & ( v5290_16__array(VarNext,A,bitIndex2)
            <=> v8242(VarNext,bitIndex57) )
            & ( v5290_16__array(VarNext,A,bitIndex1)
            <=> v8242(VarNext,bitIndex56) )
            & ( v5290_16__array(VarNext,A,bitIndex0)
            <=> v8242(VarNext,bitIndex55) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1547,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8236(VarNext)
      <=> ( v8237(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1546,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8237(VarNext)
      <=> ( v8239(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_736,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8239(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_70,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01010_address_term = A
              & v8227(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_15__array(VarNext,A,B)
              <=> v5290_14__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_70,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01010_address_term = A
            & v8227(VarNext) )
         => ( ( v5290_15__array(VarNext,A,bitIndex4)
            <=> v8233(VarNext,bitIndex54) )
            & ( v5290_15__array(VarNext,A,bitIndex3)
            <=> v8233(VarNext,bitIndex53) )
            & ( v5290_15__array(VarNext,A,bitIndex2)
            <=> v8233(VarNext,bitIndex52) )
            & ( v5290_15__array(VarNext,A,bitIndex1)
            <=> v8233(VarNext,bitIndex51) )
            & ( v5290_15__array(VarNext,A,bitIndex0)
            <=> v8233(VarNext,bitIndex50) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1545,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8227(VarNext)
      <=> ( v8228(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1544,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8228(VarNext)
      <=> ( v8230(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_735,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8230(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_69,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01001_address_term = A
              & v8218(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_14__array(VarNext,A,B)
              <=> v5290_13__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_69,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01001_address_term = A
            & v8218(VarNext) )
         => ( ( v5290_14__array(VarNext,A,bitIndex4)
            <=> v8224(VarNext,bitIndex49) )
            & ( v5290_14__array(VarNext,A,bitIndex3)
            <=> v8224(VarNext,bitIndex48) )
            & ( v5290_14__array(VarNext,A,bitIndex2)
            <=> v8224(VarNext,bitIndex47) )
            & ( v5290_14__array(VarNext,A,bitIndex1)
            <=> v8224(VarNext,bitIndex46) )
            & ( v5290_14__array(VarNext,A,bitIndex0)
            <=> v8224(VarNext,bitIndex45) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1543,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8218(VarNext)
      <=> ( v8219(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1542,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8219(VarNext)
      <=> ( v8221(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_734,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8221(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_68,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01000_address_term = A
              & v8209(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_13__array(VarNext,A,B)
              <=> v5290_12__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_68,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01000_address_term = A
            & v8209(VarNext) )
         => ( ( v5290_13__array(VarNext,A,bitIndex4)
            <=> v8215(VarNext,bitIndex44) )
            & ( v5290_13__array(VarNext,A,bitIndex3)
            <=> v8215(VarNext,bitIndex43) )
            & ( v5290_13__array(VarNext,A,bitIndex2)
            <=> v8215(VarNext,bitIndex42) )
            & ( v5290_13__array(VarNext,A,bitIndex1)
            <=> v8215(VarNext,bitIndex41) )
            & ( v5290_13__array(VarNext,A,bitIndex0)
            <=> v8215(VarNext,bitIndex40) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1541,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8209(VarNext)
      <=> ( v8210(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1540,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8210(VarNext)
      <=> ( v8212(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_733,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8212(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_67,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00111_address_term = A
              & v8200(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_12__array(VarNext,A,B)
              <=> v5290_11__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_67,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00111_address_term = A
            & v8200(VarNext) )
         => ( ( v5290_12__array(VarNext,A,bitIndex4)
            <=> v8206(VarNext,bitIndex39) )
            & ( v5290_12__array(VarNext,A,bitIndex3)
            <=> v8206(VarNext,bitIndex38) )
            & ( v5290_12__array(VarNext,A,bitIndex2)
            <=> v8206(VarNext,bitIndex37) )
            & ( v5290_12__array(VarNext,A,bitIndex1)
            <=> v8206(VarNext,bitIndex36) )
            & ( v5290_12__array(VarNext,A,bitIndex0)
            <=> v8206(VarNext,bitIndex35) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1539,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8200(VarNext)
      <=> ( v8201(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1538,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8201(VarNext)
      <=> ( v8203(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_732,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8203(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_66,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00110_address_term = A
              & v8191(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_11__array(VarNext,A,B)
              <=> v5290_10__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_66,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00110_address_term = A
            & v8191(VarNext) )
         => ( ( v5290_11__array(VarNext,A,bitIndex4)
            <=> v8197(VarNext,bitIndex34) )
            & ( v5290_11__array(VarNext,A,bitIndex3)
            <=> v8197(VarNext,bitIndex33) )
            & ( v5290_11__array(VarNext,A,bitIndex2)
            <=> v8197(VarNext,bitIndex32) )
            & ( v5290_11__array(VarNext,A,bitIndex1)
            <=> v8197(VarNext,bitIndex31) )
            & ( v5290_11__array(VarNext,A,bitIndex0)
            <=> v8197(VarNext,bitIndex30) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1537,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8191(VarNext)
      <=> ( v8192(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1536,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8192(VarNext)
      <=> ( v8194(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_731,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8194(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_65,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00101_address_term = A
              & v8182(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_10__array(VarNext,A,B)
              <=> v5290_9__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_65,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00101_address_term = A
            & v8182(VarNext) )
         => ( ( v5290_10__array(VarNext,A,bitIndex4)
            <=> v8188(VarNext,bitIndex29) )
            & ( v5290_10__array(VarNext,A,bitIndex3)
            <=> v8188(VarNext,bitIndex28) )
            & ( v5290_10__array(VarNext,A,bitIndex2)
            <=> v8188(VarNext,bitIndex27) )
            & ( v5290_10__array(VarNext,A,bitIndex1)
            <=> v8188(VarNext,bitIndex26) )
            & ( v5290_10__array(VarNext,A,bitIndex0)
            <=> v8188(VarNext,bitIndex25) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1535,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8182(VarNext)
      <=> ( v8183(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1534,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8183(VarNext)
      <=> ( v8185(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_730,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8185(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_64,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00100_address_term = A
              & v8173(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_9__array(VarNext,A,B)
              <=> v5290_8__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_64,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00100_address_term = A
            & v8173(VarNext) )
         => ( ( v5290_9__array(VarNext,A,bitIndex4)
            <=> v8179(VarNext,bitIndex24) )
            & ( v5290_9__array(VarNext,A,bitIndex3)
            <=> v8179(VarNext,bitIndex23) )
            & ( v5290_9__array(VarNext,A,bitIndex2)
            <=> v8179(VarNext,bitIndex22) )
            & ( v5290_9__array(VarNext,A,bitIndex1)
            <=> v8179(VarNext,bitIndex21) )
            & ( v5290_9__array(VarNext,A,bitIndex0)
            <=> v8179(VarNext,bitIndex20) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1533,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8173(VarNext)
      <=> ( v8174(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1532,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8174(VarNext)
      <=> ( v8176(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_729,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8176(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_63,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00011_address_term = A
              & v8164(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_8__array(VarNext,A,B)
              <=> v5290_7__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_63,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00011_address_term = A
            & v8164(VarNext) )
         => ( ( v5290_8__array(VarNext,A,bitIndex4)
            <=> v8170(VarNext,bitIndex19) )
            & ( v5290_8__array(VarNext,A,bitIndex3)
            <=> v8170(VarNext,bitIndex18) )
            & ( v5290_8__array(VarNext,A,bitIndex2)
            <=> v8170(VarNext,bitIndex17) )
            & ( v5290_8__array(VarNext,A,bitIndex1)
            <=> v8170(VarNext,bitIndex16) )
            & ( v5290_8__array(VarNext,A,bitIndex0)
            <=> v8170(VarNext,bitIndex15) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1531,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8164(VarNext)
      <=> ( v8165(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1530,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8165(VarNext)
      <=> ( v8167(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_728,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8167(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_62,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00010_address_term = A
              & v8155(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_7__array(VarNext,A,B)
              <=> v5290_6__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_62,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00010_address_term = A
            & v8155(VarNext) )
         => ( ( v5290_7__array(VarNext,A,bitIndex4)
            <=> v8161(VarNext,bitIndex14) )
            & ( v5290_7__array(VarNext,A,bitIndex3)
            <=> v8161(VarNext,bitIndex13) )
            & ( v5290_7__array(VarNext,A,bitIndex2)
            <=> v8161(VarNext,bitIndex12) )
            & ( v5290_7__array(VarNext,A,bitIndex1)
            <=> v8161(VarNext,bitIndex11) )
            & ( v5290_7__array(VarNext,A,bitIndex0)
            <=> v8161(VarNext,bitIndex10) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1529,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8155(VarNext)
      <=> ( v8156(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1528,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8156(VarNext)
      <=> ( v8158(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_727,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8158(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_61,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00001_address_term = A
              & v8146(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_6__array(VarNext,A,B)
              <=> v5290_5__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_61,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00001_address_term = A
            & v8146(VarNext) )
         => ( ( v5290_6__array(VarNext,A,bitIndex4)
            <=> v8152(VarNext,bitIndex9) )
            & ( v5290_6__array(VarNext,A,bitIndex3)
            <=> v8152(VarNext,bitIndex8) )
            & ( v5290_6__array(VarNext,A,bitIndex2)
            <=> v8152(VarNext,bitIndex7) )
            & ( v5290_6__array(VarNext,A,bitIndex1)
            <=> v8152(VarNext,bitIndex6) )
            & ( v5290_6__array(VarNext,A,bitIndex0)
            <=> v8152(VarNext,bitIndex5) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1527,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8146(VarNext)
      <=> ( v8147(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1526,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8147(VarNext)
      <=> ( v8149(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_726,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8149(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_60,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00000_address_term = A
              & v8132(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_5__array(VarNext,A,B)
              <=> v5290_4__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_60,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00000_address_term = A
            & v8132(VarNext) )
         => ! [B] :
              ( range_4_0(B)
             => ( v5290_5__array(VarNext,A,B)
              <=> v8143(VarNext,B) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1525,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8132(VarNext)
      <=> ( v8133(VarNext)
          & v8139(VarNext) ) ) ) ).

fof(addAssignment_1908,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8139(VarNext)
      <=> v8137(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1524,axiom,
    ! [VarCurr] :
      ( v8137(VarCurr)
    <=> ( v8095(VarCurr)
        & v8140(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_505,axiom,
    ! [VarCurr] :
      ( v8140(VarCurr)
    <=> ( ( v8141(VarCurr,bitIndex1)
        <=> $false )
        & ( v8141(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1907,axiom,
    ! [VarCurr] :
      ( v8141(VarCurr,bitIndex0)
    <=> v5319(VarCurr) ) ).

fof(addAssignment_1906,axiom,
    ! [VarCurr] :
      ( v8141(VarCurr,bitIndex1)
    <=> v5296(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1523,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8133(VarNext)
      <=> ( v8135(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_725,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8135(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_59,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v5575_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ~ ( A = AssociatedAddressVar
                  & v8120(VarNext) )
             => ! [B] :
                  ( range_4_0(B)
                 => ( v5290_4__array(VarNext,A,B)
                  <=> v5290_3__array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_59,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v5575_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ( A = AssociatedAddressVar
                & v8120(VarNext) )
             => ! [B] :
                  ( range_4_0(B)
                 => ( v5290_4__array(VarNext,A,B)
                  <=> v5567(VarNext,B) ) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1522,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8120(VarNext)
      <=> ( v8121(VarNext)
          & v8127(VarNext) ) ) ) ).

fof(addAssignment_1905,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8127(VarNext)
      <=> v8125(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1521,axiom,
    ! [VarCurr] :
      ( v8125(VarCurr)
    <=> ( v8095(VarCurr)
        & v8128(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_504,axiom,
    ! [VarCurr] :
      ( v8128(VarCurr)
    <=> ( ( v8129(VarCurr,bitIndex1)
        <=> $true )
        & ( v8129(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1904,axiom,
    ! [VarCurr] :
      ( v8129(VarCurr,bitIndex0)
    <=> v5319(VarCurr) ) ).

fof(addAssignment_1903,axiom,
    ! [VarCurr] :
      ( v8129(VarCurr,bitIndex1)
    <=> v5296(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1520,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8121(VarNext)
      <=> ( v8123(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_724,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8123(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_58,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v7750_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ~ ( A = AssociatedAddressVar
                  & v8108(VarNext) )
             => ! [B] :
                  ( range_4_0(B)
                 => ( v5290_3__array(VarNext,A,B)
                  <=> v5290_2__array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_58,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v7750_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ( A = AssociatedAddressVar
                & v8108(VarNext) )
             => ! [B] :
                  ( range_4_0(B)
                 => ( v5290_3__array(VarNext,A,B)
                  <=> v5609(VarNext,B) ) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1519,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8108(VarNext)
      <=> ( v8109(VarNext)
          & v8115(VarNext) ) ) ) ).

fof(addAssignment_1902,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8115(VarNext)
      <=> v8113(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1518,axiom,
    ! [VarCurr] :
      ( v8113(VarCurr)
    <=> ( v8095(VarCurr)
        & v8116(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_503,axiom,
    ! [VarCurr] :
      ( v8116(VarCurr)
    <=> ( ( v8117(VarCurr,bitIndex1)
        <=> $false )
        & ( v8117(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1901,axiom,
    ! [VarCurr] :
      ( v8117(VarCurr,bitIndex0)
    <=> v5319(VarCurr) ) ).

fof(addAssignment_1900,axiom,
    ! [VarCurr] :
      ( v8117(VarCurr,bitIndex1)
    <=> v5296(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1517,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8109(VarNext)
      <=> ( v8111(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_723,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8111(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_57,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v7750_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ~ ( A = AssociatedAddressVar
                  & v8101(VarNext) )
             => ! [B] :
                  ( range_4_0(B)
                 => ( v5290_2__array(VarNext,A,B)
                  <=> v5290_1__array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_57,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v7750_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ( A = AssociatedAddressVar
                & v8101(VarNext) )
             => ! [B] :
                  ( range_4_0(B)
                 => ( v5290_2__array(VarNext,A,B)
                  <=> v5609(VarNext,B) ) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1516,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8101(VarNext)
      <=> ( v8102(VarNext)
          & v8094(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1515,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8102(VarNext)
      <=> ( v8104(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_722,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8104(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(memoryWriteDisabled_56,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v5575_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ~ ( A = AssociatedAddressVar
                  & v8085(VarNext) )
             => ! [B] :
                  ( range_4_0(B)
                 => ( v5290_1__array(VarNext,A,B)
                  <=> v5290_array(VarCurr,A,B) ) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_56,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v5575_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ( A = AssociatedAddressVar
                & v8085(VarNext) )
             => ! [B] :
                  ( range_4_0(B)
                 => ( v5290_1__array(VarNext,A,B)
                  <=> v5567(VarNext,B) ) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1514,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8085(VarNext)
      <=> ( v8086(VarNext)
          & v8094(VarNext) ) ) ) ).

fof(addAssignment_1899,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8094(VarNext)
      <=> v8092(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1513,axiom,
    ! [VarCurr] :
      ( v8092(VarCurr)
    <=> ( v8095(VarCurr)
        & v8097(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_502,axiom,
    ! [VarCurr] :
      ( v8097(VarCurr)
    <=> ( ( v8098(VarCurr,bitIndex1)
        <=> $true )
        & ( v8098(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1898,axiom,
    ! [VarCurr] :
      ( v8098(VarCurr,bitIndex0)
    <=> v5319(VarCurr) ) ).

fof(addAssignment_1897,axiom,
    ! [VarCurr] :
      ( v8098(VarCurr,bitIndex1)
    <=> v5296(VarCurr) ) ).

fof(writeUnaryOperator_721,axiom,
    ! [VarCurr] :
      ( ~ v8095(VarCurr)
    <=> v8096(VarCurr) ) ).

fof(writeUnaryOperator_720,axiom,
    ! [VarCurr] :
      ( ~ v8096(VarCurr)
    <=> v5294(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1512,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8086(VarNext)
      <=> ( v8087(VarNext)
          & v5292(VarNext) ) ) ) ).

fof(writeUnaryOperator_719,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8087(VarNext)
      <=> v8089(VarNext) ) ) ).

fof(addAssignment_1896,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8089(VarNext)
      <=> v5292(VarCurr) ) ) ).

fof(initSateConstraint_1407,axiom,
    ~ v5290_array(constB0,b11111_address_term,bitIndex0) ).

fof(initSateConstraint_1406,axiom,
    ~ v5290_array(constB0,b11111_address_term,bitIndex1) ).

fof(initSateConstraint_1405,axiom,
    ~ v5290_array(constB0,b11111_address_term,bitIndex2) ).

fof(initSateConstraint_1404,axiom,
    ~ v5290_array(constB0,b11111_address_term,bitIndex3) ).

fof(initSateConstraint_1403,axiom,
    ~ v5290_array(constB0,b11111_address_term,bitIndex4) ).

fof(initSateConstraint_1402,axiom,
    ~ v5290_array(constB0,b11110_address_term,bitIndex0) ).

fof(initSateConstraint_1401,axiom,
    ~ v5290_array(constB0,b11110_address_term,bitIndex1) ).

fof(initSateConstraint_1400,axiom,
    ~ v5290_array(constB0,b11110_address_term,bitIndex2) ).

fof(initSateConstraint_1399,axiom,
    ~ v5290_array(constB0,b11110_address_term,bitIndex3) ).

fof(initSateConstraint_1398,axiom,
    ~ v5290_array(constB0,b11110_address_term,bitIndex4) ).

fof(initSateConstraint_1397,axiom,
    ~ v5290_array(constB0,b11101_address_term,bitIndex0) ).

fof(initSateConstraint_1396,axiom,
    ~ v5290_array(constB0,b11101_address_term,bitIndex1) ).

fof(initSateConstraint_1395,axiom,
    ~ v5290_array(constB0,b11101_address_term,bitIndex2) ).

fof(initSateConstraint_1394,axiom,
    ~ v5290_array(constB0,b11101_address_term,bitIndex3) ).

fof(initSateConstraint_1393,axiom,
    ~ v5290_array(constB0,b11101_address_term,bitIndex4) ).

fof(initSateConstraint_1392,axiom,
    ~ v5290_array(constB0,b11100_address_term,bitIndex0) ).

fof(initSateConstraint_1391,axiom,
    ~ v5290_array(constB0,b11100_address_term,bitIndex1) ).

fof(initSateConstraint_1390,axiom,
    ~ v5290_array(constB0,b11100_address_term,bitIndex2) ).

fof(initSateConstraint_1389,axiom,
    ~ v5290_array(constB0,b11100_address_term,bitIndex3) ).

fof(initSateConstraint_1388,axiom,
    ~ v5290_array(constB0,b11100_address_term,bitIndex4) ).

fof(initSateConstraint_1387,axiom,
    ~ v5290_array(constB0,b11011_address_term,bitIndex0) ).

fof(initSateConstraint_1386,axiom,
    ~ v5290_array(constB0,b11011_address_term,bitIndex1) ).

fof(initSateConstraint_1385,axiom,
    ~ v5290_array(constB0,b11011_address_term,bitIndex2) ).

fof(initSateConstraint_1384,axiom,
    ~ v5290_array(constB0,b11011_address_term,bitIndex3) ).

fof(initSateConstraint_1383,axiom,
    ~ v5290_array(constB0,b11011_address_term,bitIndex4) ).

fof(initSateConstraint_1382,axiom,
    ~ v5290_array(constB0,b11010_address_term,bitIndex0) ).

fof(initSateConstraint_1381,axiom,
    ~ v5290_array(constB0,b11010_address_term,bitIndex1) ).

fof(initSateConstraint_1380,axiom,
    ~ v5290_array(constB0,b11010_address_term,bitIndex2) ).

fof(initSateConstraint_1379,axiom,
    ~ v5290_array(constB0,b11010_address_term,bitIndex3) ).

fof(initSateConstraint_1378,axiom,
    ~ v5290_array(constB0,b11010_address_term,bitIndex4) ).

fof(initSateConstraint_1377,axiom,
    ~ v5290_array(constB0,b11001_address_term,bitIndex0) ).

fof(initSateConstraint_1376,axiom,
    ~ v5290_array(constB0,b11001_address_term,bitIndex1) ).

fof(initSateConstraint_1375,axiom,
    ~ v5290_array(constB0,b11001_address_term,bitIndex2) ).

fof(initSateConstraint_1374,axiom,
    ~ v5290_array(constB0,b11001_address_term,bitIndex3) ).

fof(initSateConstraint_1373,axiom,
    ~ v5290_array(constB0,b11001_address_term,bitIndex4) ).

fof(initSateConstraint_1372,axiom,
    ~ v5290_array(constB0,b11000_address_term,bitIndex0) ).

fof(initSateConstraint_1371,axiom,
    ~ v5290_array(constB0,b11000_address_term,bitIndex1) ).

fof(initSateConstraint_1370,axiom,
    ~ v5290_array(constB0,b11000_address_term,bitIndex2) ).

fof(initSateConstraint_1369,axiom,
    ~ v5290_array(constB0,b11000_address_term,bitIndex3) ).

fof(initSateConstraint_1368,axiom,
    ~ v5290_array(constB0,b11000_address_term,bitIndex4) ).

fof(initSateConstraint_1367,axiom,
    ~ v5290_array(constB0,b10111_address_term,bitIndex0) ).

fof(initSateConstraint_1366,axiom,
    ~ v5290_array(constB0,b10111_address_term,bitIndex1) ).

fof(initSateConstraint_1365,axiom,
    ~ v5290_array(constB0,b10111_address_term,bitIndex2) ).

fof(initSateConstraint_1364,axiom,
    ~ v5290_array(constB0,b10111_address_term,bitIndex3) ).

fof(initSateConstraint_1363,axiom,
    ~ v5290_array(constB0,b10111_address_term,bitIndex4) ).

fof(initSateConstraint_1362,axiom,
    ~ v5290_array(constB0,b10110_address_term,bitIndex0) ).

fof(initSateConstraint_1361,axiom,
    ~ v5290_array(constB0,b10110_address_term,bitIndex1) ).

fof(initSateConstraint_1360,axiom,
    ~ v5290_array(constB0,b10110_address_term,bitIndex2) ).

fof(initSateConstraint_1359,axiom,
    ~ v5290_array(constB0,b10110_address_term,bitIndex3) ).

fof(initSateConstraint_1358,axiom,
    ~ v5290_array(constB0,b10110_address_term,bitIndex4) ).

fof(initSateConstraint_1357,axiom,
    ~ v5290_array(constB0,b10101_address_term,bitIndex0) ).

fof(initSateConstraint_1356,axiom,
    ~ v5290_array(constB0,b10101_address_term,bitIndex1) ).

fof(initSateConstraint_1355,axiom,
    ~ v5290_array(constB0,b10101_address_term,bitIndex2) ).

fof(initSateConstraint_1354,axiom,
    ~ v5290_array(constB0,b10101_address_term,bitIndex3) ).

fof(initSateConstraint_1353,axiom,
    ~ v5290_array(constB0,b10101_address_term,bitIndex4) ).

fof(initSateConstraint_1352,axiom,
    ~ v5290_array(constB0,b10100_address_term,bitIndex0) ).

fof(initSateConstraint_1351,axiom,
    ~ v5290_array(constB0,b10100_address_term,bitIndex1) ).

fof(initSateConstraint_1350,axiom,
    ~ v5290_array(constB0,b10100_address_term,bitIndex2) ).

fof(initSateConstraint_1349,axiom,
    ~ v5290_array(constB0,b10100_address_term,bitIndex3) ).

fof(initSateConstraint_1348,axiom,
    ~ v5290_array(constB0,b10100_address_term,bitIndex4) ).

fof(initSateConstraint_1347,axiom,
    ~ v5290_array(constB0,b10011_address_term,bitIndex0) ).

fof(initSateConstraint_1346,axiom,
    ~ v5290_array(constB0,b10011_address_term,bitIndex1) ).

fof(initSateConstraint_1345,axiom,
    ~ v5290_array(constB0,b10011_address_term,bitIndex2) ).

fof(initSateConstraint_1344,axiom,
    ~ v5290_array(constB0,b10011_address_term,bitIndex3) ).

fof(initSateConstraint_1343,axiom,
    ~ v5290_array(constB0,b10011_address_term,bitIndex4) ).

fof(initSateConstraint_1342,axiom,
    ~ v5290_array(constB0,b10010_address_term,bitIndex0) ).

fof(initSateConstraint_1341,axiom,
    ~ v5290_array(constB0,b10010_address_term,bitIndex1) ).

fof(initSateConstraint_1340,axiom,
    ~ v5290_array(constB0,b10010_address_term,bitIndex2) ).

fof(initSateConstraint_1339,axiom,
    ~ v5290_array(constB0,b10010_address_term,bitIndex3) ).

fof(initSateConstraint_1338,axiom,
    ~ v5290_array(constB0,b10010_address_term,bitIndex4) ).

fof(initSateConstraint_1337,axiom,
    ~ v5290_array(constB0,b10001_address_term,bitIndex0) ).

fof(initSateConstraint_1336,axiom,
    ~ v5290_array(constB0,b10001_address_term,bitIndex1) ).

fof(initSateConstraint_1335,axiom,
    ~ v5290_array(constB0,b10001_address_term,bitIndex2) ).

fof(initSateConstraint_1334,axiom,
    ~ v5290_array(constB0,b10001_address_term,bitIndex3) ).

fof(initSateConstraint_1333,axiom,
    ~ v5290_array(constB0,b10001_address_term,bitIndex4) ).

fof(initSateConstraint_1332,axiom,
    ~ v5290_array(constB0,b10000_address_term,bitIndex0) ).

fof(initSateConstraint_1331,axiom,
    ~ v5290_array(constB0,b10000_address_term,bitIndex1) ).

fof(initSateConstraint_1330,axiom,
    ~ v5290_array(constB0,b10000_address_term,bitIndex2) ).

fof(initSateConstraint_1329,axiom,
    ~ v5290_array(constB0,b10000_address_term,bitIndex3) ).

fof(initSateConstraint_1328,axiom,
    ~ v5290_array(constB0,b10000_address_term,bitIndex4) ).

fof(initSateConstraint_1327,axiom,
    ~ v5290_array(constB0,b01111_address_term,bitIndex0) ).

fof(initSateConstraint_1326,axiom,
    ~ v5290_array(constB0,b01111_address_term,bitIndex1) ).

fof(initSateConstraint_1325,axiom,
    ~ v5290_array(constB0,b01111_address_term,bitIndex2) ).

fof(initSateConstraint_1324,axiom,
    ~ v5290_array(constB0,b01111_address_term,bitIndex3) ).

fof(initSateConstraint_1323,axiom,
    ~ v5290_array(constB0,b01111_address_term,bitIndex4) ).

fof(initSateConstraint_1322,axiom,
    ~ v5290_array(constB0,b01110_address_term,bitIndex0) ).

fof(initSateConstraint_1321,axiom,
    ~ v5290_array(constB0,b01110_address_term,bitIndex1) ).

fof(initSateConstraint_1320,axiom,
    ~ v5290_array(constB0,b01110_address_term,bitIndex2) ).

fof(initSateConstraint_1319,axiom,
    ~ v5290_array(constB0,b01110_address_term,bitIndex3) ).

fof(initSateConstraint_1318,axiom,
    ~ v5290_array(constB0,b01110_address_term,bitIndex4) ).

fof(initSateConstraint_1317,axiom,
    ~ v5290_array(constB0,b01101_address_term,bitIndex0) ).

fof(initSateConstraint_1316,axiom,
    ~ v5290_array(constB0,b01101_address_term,bitIndex1) ).

fof(initSateConstraint_1315,axiom,
    ~ v5290_array(constB0,b01101_address_term,bitIndex2) ).

fof(initSateConstraint_1314,axiom,
    ~ v5290_array(constB0,b01101_address_term,bitIndex3) ).

fof(initSateConstraint_1313,axiom,
    ~ v5290_array(constB0,b01101_address_term,bitIndex4) ).

fof(initSateConstraint_1312,axiom,
    ~ v5290_array(constB0,b01100_address_term,bitIndex0) ).

fof(initSateConstraint_1311,axiom,
    ~ v5290_array(constB0,b01100_address_term,bitIndex1) ).

fof(initSateConstraint_1310,axiom,
    ~ v5290_array(constB0,b01100_address_term,bitIndex2) ).

fof(initSateConstraint_1309,axiom,
    ~ v5290_array(constB0,b01100_address_term,bitIndex3) ).

fof(initSateConstraint_1308,axiom,
    ~ v5290_array(constB0,b01100_address_term,bitIndex4) ).

fof(initSateConstraint_1307,axiom,
    ~ v5290_array(constB0,b01011_address_term,bitIndex0) ).

fof(initSateConstraint_1306,axiom,
    ~ v5290_array(constB0,b01011_address_term,bitIndex1) ).

fof(initSateConstraint_1305,axiom,
    ~ v5290_array(constB0,b01011_address_term,bitIndex2) ).

fof(initSateConstraint_1304,axiom,
    ~ v5290_array(constB0,b01011_address_term,bitIndex3) ).

fof(initSateConstraint_1303,axiom,
    ~ v5290_array(constB0,b01011_address_term,bitIndex4) ).

fof(initSateConstraint_1302,axiom,
    ~ v5290_array(constB0,b01010_address_term,bitIndex0) ).

fof(initSateConstraint_1301,axiom,
    ~ v5290_array(constB0,b01010_address_term,bitIndex1) ).

fof(initSateConstraint_1300,axiom,
    ~ v5290_array(constB0,b01010_address_term,bitIndex2) ).

fof(initSateConstraint_1299,axiom,
    ~ v5290_array(constB0,b01010_address_term,bitIndex3) ).

fof(initSateConstraint_1298,axiom,
    ~ v5290_array(constB0,b01010_address_term,bitIndex4) ).

fof(initSateConstraint_1297,axiom,
    ~ v5290_array(constB0,b01001_address_term,bitIndex0) ).

fof(initSateConstraint_1296,axiom,
    ~ v5290_array(constB0,b01001_address_term,bitIndex1) ).

fof(initSateConstraint_1295,axiom,
    ~ v5290_array(constB0,b01001_address_term,bitIndex2) ).

fof(initSateConstraint_1294,axiom,
    ~ v5290_array(constB0,b01001_address_term,bitIndex3) ).

fof(initSateConstraint_1293,axiom,
    ~ v5290_array(constB0,b01001_address_term,bitIndex4) ).

fof(initSateConstraint_1292,axiom,
    ~ v5290_array(constB0,b01000_address_term,bitIndex0) ).

fof(initSateConstraint_1291,axiom,
    ~ v5290_array(constB0,b01000_address_term,bitIndex1) ).

fof(initSateConstraint_1290,axiom,
    ~ v5290_array(constB0,b01000_address_term,bitIndex2) ).

fof(initSateConstraint_1289,axiom,
    ~ v5290_array(constB0,b01000_address_term,bitIndex3) ).

fof(initSateConstraint_1288,axiom,
    ~ v5290_array(constB0,b01000_address_term,bitIndex4) ).

fof(initSateConstraint_1287,axiom,
    ~ v5290_array(constB0,b00111_address_term,bitIndex0) ).

fof(initSateConstraint_1286,axiom,
    ~ v5290_array(constB0,b00111_address_term,bitIndex1) ).

fof(initSateConstraint_1285,axiom,
    ~ v5290_array(constB0,b00111_address_term,bitIndex2) ).

fof(initSateConstraint_1284,axiom,
    ~ v5290_array(constB0,b00111_address_term,bitIndex3) ).

fof(initSateConstraint_1283,axiom,
    ~ v5290_array(constB0,b00111_address_term,bitIndex4) ).

fof(initSateConstraint_1282,axiom,
    ~ v5290_array(constB0,b00110_address_term,bitIndex0) ).

fof(initSateConstraint_1281,axiom,
    ~ v5290_array(constB0,b00110_address_term,bitIndex1) ).

fof(initSateConstraint_1280,axiom,
    ~ v5290_array(constB0,b00110_address_term,bitIndex2) ).

fof(initSateConstraint_1279,axiom,
    ~ v5290_array(constB0,b00110_address_term,bitIndex3) ).

fof(initSateConstraint_1278,axiom,
    ~ v5290_array(constB0,b00110_address_term,bitIndex4) ).

fof(initSateConstraint_1277,axiom,
    ~ v5290_array(constB0,b00101_address_term,bitIndex0) ).

fof(initSateConstraint_1276,axiom,
    ~ v5290_array(constB0,b00101_address_term,bitIndex1) ).

fof(initSateConstraint_1275,axiom,
    ~ v5290_array(constB0,b00101_address_term,bitIndex2) ).

fof(initSateConstraint_1274,axiom,
    ~ v5290_array(constB0,b00101_address_term,bitIndex3) ).

fof(initSateConstraint_1273,axiom,
    ~ v5290_array(constB0,b00101_address_term,bitIndex4) ).

fof(initSateConstraint_1272,axiom,
    ~ v5290_array(constB0,b00100_address_term,bitIndex0) ).

fof(initSateConstraint_1271,axiom,
    ~ v5290_array(constB0,b00100_address_term,bitIndex1) ).

fof(initSateConstraint_1270,axiom,
    ~ v5290_array(constB0,b00100_address_term,bitIndex2) ).

fof(initSateConstraint_1269,axiom,
    ~ v5290_array(constB0,b00100_address_term,bitIndex3) ).

fof(initSateConstraint_1268,axiom,
    ~ v5290_array(constB0,b00100_address_term,bitIndex4) ).

fof(initSateConstraint_1267,axiom,
    ~ v5290_array(constB0,b00011_address_term,bitIndex0) ).

fof(initSateConstraint_1266,axiom,
    ~ v5290_array(constB0,b00011_address_term,bitIndex1) ).

fof(initSateConstraint_1265,axiom,
    ~ v5290_array(constB0,b00011_address_term,bitIndex2) ).

fof(initSateConstraint_1264,axiom,
    ~ v5290_array(constB0,b00011_address_term,bitIndex3) ).

fof(initSateConstraint_1263,axiom,
    ~ v5290_array(constB0,b00011_address_term,bitIndex4) ).

fof(initSateConstraint_1262,axiom,
    ~ v5290_array(constB0,b00010_address_term,bitIndex0) ).

fof(initSateConstraint_1261,axiom,
    ~ v5290_array(constB0,b00010_address_term,bitIndex1) ).

fof(initSateConstraint_1260,axiom,
    ~ v5290_array(constB0,b00010_address_term,bitIndex2) ).

fof(initSateConstraint_1259,axiom,
    ~ v5290_array(constB0,b00010_address_term,bitIndex3) ).

fof(initSateConstraint_1258,axiom,
    ~ v5290_array(constB0,b00010_address_term,bitIndex4) ).

fof(initSateConstraint_1257,axiom,
    ~ v5290_array(constB0,b00001_address_term,bitIndex0) ).

fof(initSateConstraint_1256,axiom,
    ~ v5290_array(constB0,b00001_address_term,bitIndex1) ).

fof(initSateConstraint_1255,axiom,
    ~ v5290_array(constB0,b00001_address_term,bitIndex2) ).

fof(initSateConstraint_1254,axiom,
    ~ v5290_array(constB0,b00001_address_term,bitIndex3) ).

fof(initSateConstraint_1253,axiom,
    ~ v5290_array(constB0,b00001_address_term,bitIndex4) ).

fof(initSateConstraint_1252,axiom,
    v5290_array(constB0,b00000_address_term,bitIndex0) ).

fof(initSateConstraint_1251,axiom,
    v5290_array(constB0,b00000_address_term,bitIndex1) ).

fof(initSateConstraint_1250,axiom,
    v5290_array(constB0,b00000_address_term,bitIndex2) ).

fof(initSateConstraint_1249,axiom,
    v5290_array(constB0,b00000_address_term,bitIndex3) ).

fof(initSateConstraint_1248,axiom,
    v5290_array(constB0,b00000_address_term,bitIndex4) ).

fof(addAssignment_1895,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v5609(VarCurr,B)
      <=> v5611(VarCurr,B) ) ) ).

fof(addAssignment_1894,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v5611(VarCurr,B)
      <=> v5613(VarCurr,B) ) ) ).

fof(addAssignment_1893,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v5613(VarCurr,B)
      <=> v5615(VarCurr,B) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_133,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8067(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v5615(VarNext,B)
            <=> v5615(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_140,axiom,
    ! [VarNext] :
      ( v8067(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v5615(VarNext,B)
          <=> v8078(VarNext,B) ) ) ) ).

fof(addAssignment_1892,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v8078(VarNext,B)
          <=> v8076(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_194,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v8076(VarCurr,B)
          <=> v8079(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_196,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v8076(VarCurr,B)
          <=> $false ) ) ) ).

fof(addAssignment_1891,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v8079(VarCurr,B)
      <=> v5617(VarCurr,B) ) ) ).

fof(addAssignment_1890,axiom,
    ! [VarCurr] :
      ( v8079(VarCurr,bitIndex4)
    <=> $true ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1511,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8067(VarNext)
      <=> ( v8068(VarNext)
          & v8075(VarNext) ) ) ) ).

fof(addAssignment_1889,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8075(VarNext)
      <=> v8073(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1510,axiom,
    ! [VarCurr] :
      ( v8073(VarCurr)
    <=> ( v5327(VarCurr)
        | v5397(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1509,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8068(VarNext)
      <=> ( v8070(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_718,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8070(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_132,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8049(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v5617(VarNext,B)
            <=> v5617(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_139,axiom,
    ! [VarNext] :
      ( v8049(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v5617(VarNext,B)
          <=> v8061(VarNext,B) ) ) ) ).

fof(addAssignment_1888,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v8061(VarNext,B)
          <=> v8059(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_193,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8059(VarCurr,B)
          <=> v8062(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_195,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8059(VarCurr,B)
          <=> $false ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_192,axiom,
    ! [VarCurr] :
      ( ~ v5619(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8062(VarCurr,B)
          <=> v7875(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_194,axiom,
    ! [VarCurr] :
      ( v5619(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8062(VarCurr,B)
          <=> v5282(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1508,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8049(VarNext)
      <=> ( v8050(VarNext)
          & v8057(VarNext) ) ) ) ).

fof(addAssignment_1887,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8057(VarNext)
      <=> v8055(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1507,axiom,
    ! [VarCurr] :
      ( v8055(VarCurr)
    <=> ( v8058(VarCurr)
        | v5397(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1506,axiom,
    ! [VarCurr] :
      ( v8058(VarCurr)
    <=> ( v5355(VarCurr)
        | v5619(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1505,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8050(VarNext)
      <=> ( v8052(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_717,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8052(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignment_1886,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v7875(VarCurr,B)
      <=> v7877(VarCurr,B) ) ) ).

fof(addAssignment_1885,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v7877(VarCurr,B)
      <=> v7879(VarCurr,B) ) ) ).

fof(addAssignment_1884,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v7879(VarCurr,B)
      <=> v7881(VarCurr,B) ) ) ).

fof(addAssignment_1883,axiom,
    ! [VarCurr] :
      ( ( v7881(VarCurr,bitIndex3)
      <=> v7883(VarCurr,bitIndex63) )
      & ( v7881(VarCurr,bitIndex2)
      <=> v7883(VarCurr,bitIndex62) )
      & ( v7881(VarCurr,bitIndex1)
      <=> v7883(VarCurr,bitIndex61) )
      & ( v7881(VarCurr,bitIndex0)
      <=> v7883(VarCurr,bitIndex60) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_131,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8013(VarNext)
       => ! [B] :
            ( range_63_60(B)
           => ( v7883(VarNext,B)
            <=> v7883(VarCurr,B) ) ) ) ) ).

fof(range_axiom_50,axiom,
    ! [B] :
      ( range_63_60(B)
    <=> ( $false
        | bitIndex60 = B
        | bitIndex61 = B
        | bitIndex62 = B
        | bitIndex63 = B ) ) ).

fof(addCaseBooleanConditionShiftedRanges0_8,axiom,
    ! [VarNext] :
      ( v8013(VarNext)
     => ( ( v7883(VarNext,bitIndex63)
        <=> v8043(VarNext,bitIndex3) )
        & ( v7883(VarNext,bitIndex62)
        <=> v8043(VarNext,bitIndex2) )
        & ( v7883(VarNext,bitIndex61)
        <=> v8043(VarNext,bitIndex1) )
        & ( v7883(VarNext,bitIndex60)
        <=> v8043(VarNext,bitIndex0) ) ) ) ).

fof(addAssignment_1882,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v8043(VarNext,B)
          <=> v8041(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_161,axiom,
    ! [VarCurr] :
      ( ~ v7972(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8041(VarCurr,B)
          <=> v8044(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_151,axiom,
    ! [VarCurr] :
      ( v7972(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8041(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_66,axiom,
    ! [VarCurr] :
      ( ( ~ v8026(VarCurr)
        & ~ v8028(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v8044(VarCurr,B)
          <=> v8005(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_160,axiom,
    ! [VarCurr] :
      ( v8028(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8044(VarCurr,B)
          <=> v7998(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0_9,axiom,
    ! [VarCurr] :
      ( v8026(VarCurr)
     => ( ( v8044(VarCurr,bitIndex3)
        <=> v7883(VarCurr,bitIndex59) )
        & ( v8044(VarCurr,bitIndex2)
        <=> v7883(VarCurr,bitIndex58) )
        & ( v8044(VarCurr,bitIndex1)
        <=> v7883(VarCurr,bitIndex57) )
        & ( v8044(VarCurr,bitIndex0)
        <=> v7883(VarCurr,bitIndex56) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1504,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8013(VarNext)
      <=> ( v8014(VarNext)
          & v8021(VarNext) ) ) ) ).

fof(addAssignment_1881,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8021(VarNext)
      <=> v8019(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1503,axiom,
    ! [VarCurr] :
      ( v8019(VarCurr)
    <=> ( v8022(VarCurr)
        & v8033(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1502,axiom,
    ! [VarCurr] :
      ( v8033(VarCurr)
    <=> ( v8034(VarCurr)
        | v7972(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1501,axiom,
    ! [VarCurr] :
      ( v8034(VarCurr)
    <=> ( v8035(VarCurr)
        & v8038(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1500,axiom,
    ! [VarCurr] :
      ( v8038(VarCurr)
    <=> ( v8039(VarCurr)
        | v8030(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1499,axiom,
    ! [VarCurr] :
      ( v8039(VarCurr)
    <=> ( v8040(VarCurr)
        | v8028(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1498,axiom,
    ! [VarCurr] :
      ( v8040(VarCurr)
    <=> ( v8036(VarCurr)
        | v8026(VarCurr) ) ) ).

fof(writeUnaryOperator_716,axiom,
    ! [VarCurr] :
      ( ~ v8035(VarCurr)
    <=> v8036(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_501,axiom,
    ! [VarCurr] :
      ( v8036(VarCurr)
    <=> ( ( v8037(VarCurr,bitIndex1)
        <=> $false )
        & ( v8037(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1880,axiom,
    ! [VarCurr] :
      ( v8037(VarCurr,bitIndex0)
    <=> v5470(VarCurr) ) ).

fof(addAssignment_1879,axiom,
    ! [VarCurr] :
      ( v8037(VarCurr,bitIndex1)
    <=> v5407(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1497,axiom,
    ! [VarCurr] :
      ( v8022(VarCurr)
    <=> ( v7972(VarCurr)
        | v8023(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1496,axiom,
    ! [VarCurr] :
      ( v8023(VarCurr)
    <=> ( v8024(VarCurr)
        & v8032(VarCurr) ) ) ).

fof(writeUnaryOperator_715,axiom,
    ! [VarCurr] :
      ( ~ v8032(VarCurr)
    <=> v7972(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1495,axiom,
    ! [VarCurr] :
      ( v8024(VarCurr)
    <=> ( v8025(VarCurr)
        | v8030(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_500,axiom,
    ! [VarCurr] :
      ( v8030(VarCurr)
    <=> ( ( v8031(VarCurr,bitIndex1)
        <=> $true )
        & ( v8031(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1878,axiom,
    ! [VarCurr] :
      ( v8031(VarCurr,bitIndex0)
    <=> v5470(VarCurr) ) ).

fof(addAssignment_1877,axiom,
    ! [VarCurr] :
      ( v8031(VarCurr,bitIndex1)
    <=> v5407(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1494,axiom,
    ! [VarCurr] :
      ( v8025(VarCurr)
    <=> ( v8026(VarCurr)
        | v8028(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_499,axiom,
    ! [VarCurr] :
      ( v8028(VarCurr)
    <=> ( ( v8029(VarCurr,bitIndex1)
        <=> $true )
        & ( v8029(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1876,axiom,
    ! [VarCurr] :
      ( v8029(VarCurr,bitIndex0)
    <=> v5470(VarCurr) ) ).

fof(addAssignment_1875,axiom,
    ! [VarCurr] :
      ( v8029(VarCurr,bitIndex1)
    <=> v5407(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_498,axiom,
    ! [VarCurr] :
      ( v8026(VarCurr)
    <=> ( ( v8027(VarCurr,bitIndex1)
        <=> $false )
        & ( v8027(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1874,axiom,
    ! [VarCurr] :
      ( v8027(VarCurr,bitIndex0)
    <=> v5470(VarCurr) ) ).

fof(addAssignment_1873,axiom,
    ! [VarCurr] :
      ( v8027(VarCurr,bitIndex1)
    <=> v5407(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1493,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v8014(VarNext)
      <=> ( v8016(VarNext)
          & v5474(VarNext) ) ) ) ).

fof(writeUnaryOperator_714,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v8016(VarNext)
      <=> v5481(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_191,axiom,
    ! [VarCurr] :
      ( ~ v8007(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8005(VarCurr,B)
          <=> v8009(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_193,axiom,
    ! [VarCurr] :
      ( v8007(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v8005(VarCurr,B)
          <=> v7939(VarCurr,B) ) ) ) ).

fof(addAssignment_1872,axiom,
    ! [VarCurr] :
      ( ( v8009(VarCurr,bitIndex3)
      <=> v7883(VarCurr,bitIndex59) )
      & ( v8009(VarCurr,bitIndex2)
      <=> v7883(VarCurr,bitIndex58) )
      & ( v8009(VarCurr,bitIndex1)
      <=> v7883(VarCurr,bitIndex57) )
      & ( v8009(VarCurr,bitIndex0)
      <=> v7883(VarCurr,bitIndex56) ) ) ).

fof(addAssignment_1871,axiom,
    ! [VarCurr] :
      ( v8007(VarCurr)
    <=> v7889(VarCurr,bitIndex1) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_190,axiom,
    ! [VarCurr] :
      ( ~ v8000(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v7998(VarCurr,B)
          <=> v8002(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_192,axiom,
    ! [VarCurr] :
      ( v8000(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v7998(VarCurr,B)
          <=> v7939(VarCurr,B) ) ) ) ).

fof(addAssignment_1870,axiom,
    ! [VarCurr] :
      ( ( v8002(VarCurr,bitIndex3)
      <=> v7883(VarCurr,bitIndex63) )
      & ( v8002(VarCurr,bitIndex2)
      <=> v7883(VarCurr,bitIndex62) )
      & ( v8002(VarCurr,bitIndex1)
      <=> v7883(VarCurr,bitIndex61) )
      & ( v8002(VarCurr,bitIndex0)
      <=> v7883(VarCurr,bitIndex60) ) ) ).

fof(addAssignment_1869,axiom,
    ! [VarCurr] :
      ( v8000(VarCurr)
    <=> v7889(VarCurr,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_130,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7962(VarNext)
       => ! [B] :
            ( range_59_56(B)
           => ( v7883(VarNext,B)
            <=> v7883(VarCurr,B) ) ) ) ) ).

fof(range_axiom_49,axiom,
    ! [B] :
      ( range_59_56(B)
    <=> ( $false
        | bitIndex56 = B
        | bitIndex57 = B
        | bitIndex58 = B
        | bitIndex59 = B ) ) ).

fof(addCaseBooleanConditionShiftedRanges0_7,axiom,
    ! [VarNext] :
      ( v7962(VarNext)
     => ( ( v7883(VarNext,bitIndex59)
        <=> v7993(VarNext,bitIndex3) )
        & ( v7883(VarNext,bitIndex58)
        <=> v7993(VarNext,bitIndex2) )
        & ( v7883(VarNext,bitIndex57)
        <=> v7993(VarNext,bitIndex1) )
        & ( v7883(VarNext,bitIndex56)
        <=> v7993(VarNext,bitIndex0) ) ) ) ).

fof(addAssignment_1868,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v7993(VarNext,B)
          <=> v7991(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_159,axiom,
    ! [VarCurr] :
      ( ~ v7972(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v7991(VarCurr,B)
          <=> v7994(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_150,axiom,
    ! [VarCurr] :
      ( v7972(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v7991(VarCurr,B)
          <=> b0001(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_65,axiom,
    ! [VarCurr] :
      ( ( ~ v7976(VarCurr)
        & ~ v7978(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v7994(VarCurr,B)
          <=> v7954(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_158,axiom,
    ! [VarCurr] :
      ( v7978(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v7994(VarCurr,B)
          <=> v7885(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0_8,axiom,
    ! [VarCurr] :
      ( v7976(VarCurr)
     => ( ( v7994(VarCurr,bitIndex3)
        <=> v7883(VarCurr,bitIndex55) )
        & ( v7994(VarCurr,bitIndex2)
        <=> v7883(VarCurr,bitIndex54) )
        & ( v7994(VarCurr,bitIndex1)
        <=> v7883(VarCurr,bitIndex53) )
        & ( v7994(VarCurr,bitIndex0)
        <=> v7883(VarCurr,bitIndex52) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1492,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7962(VarNext)
      <=> ( v7963(VarNext)
          & v7970(VarNext) ) ) ) ).

fof(addAssignment_1867,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7970(VarNext)
      <=> v7968(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1491,axiom,
    ! [VarCurr] :
      ( v7968(VarCurr)
    <=> ( v7971(VarCurr)
        & v7983(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1490,axiom,
    ! [VarCurr] :
      ( v7983(VarCurr)
    <=> ( v7984(VarCurr)
        | v7972(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1489,axiom,
    ! [VarCurr] :
      ( v7984(VarCurr)
    <=> ( v7985(VarCurr)
        & v7988(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1488,axiom,
    ! [VarCurr] :
      ( v7988(VarCurr)
    <=> ( v7989(VarCurr)
        | v7980(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1487,axiom,
    ! [VarCurr] :
      ( v7989(VarCurr)
    <=> ( v7990(VarCurr)
        | v7978(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1486,axiom,
    ! [VarCurr] :
      ( v7990(VarCurr)
    <=> ( v7986(VarCurr)
        | v7976(VarCurr) ) ) ).

fof(writeUnaryOperator_713,axiom,
    ! [VarCurr] :
      ( ~ v7985(VarCurr)
    <=> v7986(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_497,axiom,
    ! [VarCurr] :
      ( v7986(VarCurr)
    <=> ( ( v7987(VarCurr,bitIndex1)
        <=> $false )
        & ( v7987(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1866,axiom,
    ! [VarCurr] :
      ( v7987(VarCurr,bitIndex0)
    <=> v5470(VarCurr) ) ).

fof(addAssignment_1865,axiom,
    ! [VarCurr] :
      ( v7987(VarCurr,bitIndex1)
    <=> v5407(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1485,axiom,
    ! [VarCurr] :
      ( v7971(VarCurr)
    <=> ( v7972(VarCurr)
        | v7973(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1484,axiom,
    ! [VarCurr] :
      ( v7973(VarCurr)
    <=> ( v7974(VarCurr)
        & v7982(VarCurr) ) ) ).

fof(writeUnaryOperator_712,axiom,
    ! [VarCurr] :
      ( ~ v7982(VarCurr)
    <=> v7972(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1483,axiom,
    ! [VarCurr] :
      ( v7974(VarCurr)
    <=> ( v7975(VarCurr)
        | v7980(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_496,axiom,
    ! [VarCurr] :
      ( v7980(VarCurr)
    <=> ( ( v7981(VarCurr,bitIndex1)
        <=> $true )
        & ( v7981(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1864,axiom,
    ! [VarCurr] :
      ( v7981(VarCurr,bitIndex0)
    <=> v5470(VarCurr) ) ).

fof(addAssignment_1863,axiom,
    ! [VarCurr] :
      ( v7981(VarCurr,bitIndex1)
    <=> v5407(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1482,axiom,
    ! [VarCurr] :
      ( v7975(VarCurr)
    <=> ( v7976(VarCurr)
        | v7978(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_495,axiom,
    ! [VarCurr] :
      ( v7978(VarCurr)
    <=> ( ( v7979(VarCurr,bitIndex1)
        <=> $true )
        & ( v7979(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1862,axiom,
    ! [VarCurr] :
      ( v7979(VarCurr,bitIndex0)
    <=> v5470(VarCurr) ) ).

fof(addAssignment_1861,axiom,
    ! [VarCurr] :
      ( v7979(VarCurr,bitIndex1)
    <=> v5407(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_494,axiom,
    ! [VarCurr] :
      ( v7976(VarCurr)
    <=> ( ( v7977(VarCurr,bitIndex1)
        <=> $false )
        & ( v7977(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1860,axiom,
    ! [VarCurr] :
      ( v7977(VarCurr,bitIndex0)
    <=> v5470(VarCurr) ) ).

fof(addAssignment_1859,axiom,
    ! [VarCurr] :
      ( v7977(VarCurr,bitIndex1)
    <=> v5407(VarCurr) ) ).

fof(writeUnaryOperator_711,axiom,
    ! [VarCurr] :
      ( ~ v7972(VarCurr)
    <=> v5405(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1481,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7963(VarNext)
      <=> ( v7964(VarNext)
          & v5474(VarNext) ) ) ) ).

fof(writeUnaryOperator_710,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7964(VarNext)
      <=> v5481(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_189,axiom,
    ! [VarCurr] :
      ( ~ v7956(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v7954(VarCurr,B)
          <=> v7958(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_191,axiom,
    ! [VarCurr] :
      ( v7956(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v7954(VarCurr,B)
          <=> v7939(VarCurr,B) ) ) ) ).

fof(addAssignment_1858,axiom,
    ! [VarCurr] :
      ( ( v7958(VarCurr,bitIndex3)
      <=> v7883(VarCurr,bitIndex55) )
      & ( v7958(VarCurr,bitIndex2)
      <=> v7883(VarCurr,bitIndex54) )
      & ( v7958(VarCurr,bitIndex1)
      <=> v7883(VarCurr,bitIndex53) )
      & ( v7958(VarCurr,bitIndex0)
      <=> v7883(VarCurr,bitIndex52) ) ) ).

fof(addAssignment_1857,axiom,
    ! [VarCurr] :
      ( v7956(VarCurr)
    <=> v7889(VarCurr,bitIndex2) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_188,axiom,
    ! [VarCurr] :
      ( ~ v7887(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v7885(VarCurr,B)
          <=> v7951(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_190,axiom,
    ! [VarCurr] :
      ( v7887(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v7885(VarCurr,B)
          <=> v7939(VarCurr,B) ) ) ) ).

fof(addAssignment_1856,axiom,
    ! [VarCurr] :
      ( ( v7951(VarCurr,bitIndex3)
      <=> v7883(VarCurr,bitIndex59) )
      & ( v7951(VarCurr,bitIndex2)
      <=> v7883(VarCurr,bitIndex58) )
      & ( v7951(VarCurr,bitIndex1)
      <=> v7883(VarCurr,bitIndex57) )
      & ( v7951(VarCurr,bitIndex0)
      <=> v7883(VarCurr,bitIndex56) ) ) ).

fof(addAssignmentInitValueVector_36,axiom,
    ( ( v7883(constB0,bitIndex63)
    <=> $false )
    & ( v7883(constB0,bitIndex62)
    <=> $false )
    & ( v7883(constB0,bitIndex61)
    <=> $false )
    & ( v7883(constB0,bitIndex60)
    <=> $false ) ) ).

fof(addAssignment_1855,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v7939(VarCurr,B)
      <=> v7941(VarCurr,B) ) ) ).

fof(addAssignment_1854,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v7941(VarCurr,B)
      <=> v5432(VarCurr,B) ) ) ).

fof(addAssignment_1853,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v5432(VarCurr,B)
      <=> v5434(VarCurr,B) ) ) ).

fof(addAssignment_1852,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v5434(VarCurr,B)
      <=> v5436(VarCurr,B) ) ) ).

fof(addAssignment_1851,axiom,
    ! [VarNext,B] :
      ( range_3_0(B)
     => ( v5436(VarNext,B)
      <=> v7943(VarNext,B) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_129,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7945(VarNext)
       => ! [B] :
            ( range_16_0(B)
           => ( v7943(VarNext,B)
            <=> v5436(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_138,axiom,
    ! [VarNext] :
      ( v7945(VarNext)
     => ! [B] :
          ( range_16_0(B)
         => ( v7943(VarNext,B)
          <=> v5453(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1480,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7945(VarNext)
      <=> ( v7946(VarNext)
          & v5450(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1479,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7946(VarNext)
      <=> ( v7948(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_709,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7948(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignment_1850,axiom,
    ! [VarCurr] :
      ( v7887(VarCurr)
    <=> v7889(VarCurr,bitIndex2) ) ).

fof(addAssignment_1849,axiom,
    ! [VarCurr] :
      ( v7889(VarCurr,bitIndex2)
    <=> v7907(VarCurr,bitIndex2) ) ).

fof(addAssignment_1848,axiom,
    ! [VarNext] :
      ( v7892(VarNext,bitIndex1)
    <=> v7931(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_128,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7932(VarNext)
       => ! [B] :
            ( range_16_0(B)
           => ( v7931(VarNext,B)
            <=> v7892(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_137,axiom,
    ! [VarNext] :
      ( v7932(VarNext)
     => ! [B] :
          ( range_16_0(B)
         => ( v7931(VarNext,B)
          <=> v7903(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1478,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7932(VarNext)
      <=> v7933(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1477,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7933(VarNext)
      <=> ( v7935(VarNext)
          & v5474(VarNext) ) ) ) ).

fof(writeUnaryOperator_708,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7935(VarNext)
      <=> v5481(VarNext) ) ) ).

fof(addAssignment_1847,axiom,
    ! [VarCurr] :
      ( v7889(VarCurr,bitIndex1)
    <=> v7907(VarCurr,bitIndex1) ) ).

fof(addAssignment_1846,axiom,
    ! [VarNext] :
      ( v7892(VarNext,bitIndex0)
    <=> v7923(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_127,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7924(VarNext)
       => ! [B] :
            ( range_16_0(B)
           => ( v7923(VarNext,B)
            <=> v7892(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_136,axiom,
    ! [VarNext] :
      ( v7924(VarNext)
     => ! [B] :
          ( range_16_0(B)
         => ( v7923(VarNext,B)
          <=> v7903(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1476,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7924(VarNext)
      <=> v7925(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1475,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7925(VarNext)
      <=> ( v7927(VarNext)
          & v5474(VarNext) ) ) ) ).

fof(writeUnaryOperator_707,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7927(VarNext)
      <=> v5481(VarNext) ) ) ).

fof(addAssignment_1845,axiom,
    ! [VarCurr] :
      ( v7889(VarCurr,bitIndex0)
    <=> v7907(VarCurr,bitIndex0) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_187,axiom,
    ! [VarCurr] :
      ( ~ v7908(VarCurr)
     => ! [B] :
          ( range_16_0(B)
         => ( v7907(VarCurr,B)
          <=> v7909(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_189,axiom,
    ! [VarCurr] :
      ( v7908(VarCurr)
     => ! [B] :
          ( range_16_0(B)
         => ( v7907(VarCurr,B)
          <=> b10000000000000000(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges4_5,axiom,
    ! [VarCurr] :
      ( ( ~ v7910(VarCurr)
        & ~ v7912(VarCurr)
        & ~ v7916(VarCurr)
        & ~ v7920(VarCurr) )
     => ! [B] :
          ( range_16_0(B)
         => ( v7909(VarCurr,B)
          <=> v7892(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_29,axiom,
    ! [VarCurr] :
      ( v7920(VarCurr)
     => ! [B] :
          ( range_16_0(B)
         => ( v7909(VarCurr,B)
          <=> v7892(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_64,axiom,
    ! [VarCurr] :
      ( v7916(VarCurr)
     => ! [B] :
          ( range_16_0(B)
         => ( v7909(VarCurr,B)
          <=> v7918(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_157,axiom,
    ! [VarCurr] :
      ( v7912(VarCurr)
     => ! [B] :
          ( range_16_0(B)
         => ( v7909(VarCurr,B)
          <=> v7914(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_149,axiom,
    ! [VarCurr] :
      ( v7910(VarCurr)
     => ! [B] :
          ( range_16_0(B)
         => ( v7909(VarCurr,B)
          <=> v7892(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_493,axiom,
    ! [VarCurr] :
      ( v7920(VarCurr)
    <=> ( ( v7921(VarCurr,bitIndex1)
        <=> $true )
        & ( v7921(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1844,axiom,
    ! [VarCurr] :
      ( v7921(VarCurr,bitIndex0)
    <=> v5470(VarCurr) ) ).

fof(addAssignment_1843,axiom,
    ! [VarCurr] :
      ( v7921(VarCurr,bitIndex1)
    <=> v5407(VarCurr) ) ).

fof(addAssignment_1842,axiom,
    ! [VarCurr] :
      ( v7918(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_1841,axiom,
    ! [VarCurr] :
      ( ( v7918(VarCurr,bitIndex16)
      <=> v7892(VarCurr,bitIndex15) )
      & ( v7918(VarCurr,bitIndex15)
      <=> v7892(VarCurr,bitIndex14) )
      & ( v7918(VarCurr,bitIndex14)
      <=> v7892(VarCurr,bitIndex13) )
      & ( v7918(VarCurr,bitIndex13)
      <=> v7892(VarCurr,bitIndex12) )
      & ( v7918(VarCurr,bitIndex12)
      <=> v7892(VarCurr,bitIndex11) )
      & ( v7918(VarCurr,bitIndex11)
      <=> v7892(VarCurr,bitIndex10) )
      & ( v7918(VarCurr,bitIndex10)
      <=> v7892(VarCurr,bitIndex9) )
      & ( v7918(VarCurr,bitIndex9)
      <=> v7892(VarCurr,bitIndex8) )
      & ( v7918(VarCurr,bitIndex8)
      <=> v7892(VarCurr,bitIndex7) )
      & ( v7918(VarCurr,bitIndex7)
      <=> v7892(VarCurr,bitIndex6) )
      & ( v7918(VarCurr,bitIndex6)
      <=> v7892(VarCurr,bitIndex5) )
      & ( v7918(VarCurr,bitIndex5)
      <=> v7892(VarCurr,bitIndex4) )
      & ( v7918(VarCurr,bitIndex4)
      <=> v7892(VarCurr,bitIndex3) )
      & ( v7918(VarCurr,bitIndex3)
      <=> v7892(VarCurr,bitIndex2) )
      & ( v7918(VarCurr,bitIndex2)
      <=> v7892(VarCurr,bitIndex1) )
      & ( v7918(VarCurr,bitIndex1)
      <=> v7892(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_492,axiom,
    ! [VarCurr] :
      ( v7916(VarCurr)
    <=> ( ( v7917(VarCurr,bitIndex1)
        <=> $true )
        & ( v7917(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1840,axiom,
    ! [VarCurr] :
      ( v7917(VarCurr,bitIndex0)
    <=> v5470(VarCurr) ) ).

fof(addAssignment_1839,axiom,
    ! [VarCurr] :
      ( v7917(VarCurr,bitIndex1)
    <=> v5407(VarCurr) ) ).

fof(addAssignment_1838,axiom,
    ! [VarCurr] :
      ( ( v7914(VarCurr,bitIndex15)
      <=> v7892(VarCurr,bitIndex16) )
      & ( v7914(VarCurr,bitIndex14)
      <=> v7892(VarCurr,bitIndex15) )
      & ( v7914(VarCurr,bitIndex13)
      <=> v7892(VarCurr,bitIndex14) )
      & ( v7914(VarCurr,bitIndex12)
      <=> v7892(VarCurr,bitIndex13) )
      & ( v7914(VarCurr,bitIndex11)
      <=> v7892(VarCurr,bitIndex12) )
      & ( v7914(VarCurr,bitIndex10)
      <=> v7892(VarCurr,bitIndex11) )
      & ( v7914(VarCurr,bitIndex9)
      <=> v7892(VarCurr,bitIndex10) )
      & ( v7914(VarCurr,bitIndex8)
      <=> v7892(VarCurr,bitIndex9) )
      & ( v7914(VarCurr,bitIndex7)
      <=> v7892(VarCurr,bitIndex8) )
      & ( v7914(VarCurr,bitIndex6)
      <=> v7892(VarCurr,bitIndex7) )
      & ( v7914(VarCurr,bitIndex5)
      <=> v7892(VarCurr,bitIndex6) )
      & ( v7914(VarCurr,bitIndex4)
      <=> v7892(VarCurr,bitIndex5) )
      & ( v7914(VarCurr,bitIndex3)
      <=> v7892(VarCurr,bitIndex4) )
      & ( v7914(VarCurr,bitIndex2)
      <=> v7892(VarCurr,bitIndex3) )
      & ( v7914(VarCurr,bitIndex1)
      <=> v7892(VarCurr,bitIndex2) )
      & ( v7914(VarCurr,bitIndex0)
      <=> v7892(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1837,axiom,
    ! [VarCurr] :
      ( v7914(VarCurr,bitIndex16)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_491,axiom,
    ! [VarCurr] :
      ( v7912(VarCurr)
    <=> ( ( v7913(VarCurr,bitIndex1)
        <=> $false )
        & ( v7913(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1836,axiom,
    ! [VarCurr] :
      ( v7913(VarCurr,bitIndex0)
    <=> v5470(VarCurr) ) ).

fof(addAssignment_1835,axiom,
    ! [VarCurr] :
      ( v7913(VarCurr,bitIndex1)
    <=> v5407(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_490,axiom,
    ! [VarCurr] :
      ( v7910(VarCurr)
    <=> ( ( v7911(VarCurr,bitIndex1)
        <=> $false )
        & ( v7911(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1834,axiom,
    ! [VarCurr] :
      ( v7911(VarCurr,bitIndex0)
    <=> v5470(VarCurr) ) ).

fof(addAssignment_1833,axiom,
    ! [VarCurr] :
      ( v7911(VarCurr,bitIndex1)
    <=> v5407(VarCurr) ) ).

fof(writeUnaryOperator_706,axiom,
    ! [VarCurr] :
      ( ~ v7908(VarCurr)
    <=> v5405(VarCurr) ) ).

fof(addAssignment_1832,axiom,
    ! [VarNext] :
      ( v7892(VarNext,bitIndex2)
    <=> v7894(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_126,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7895(VarNext)
       => ! [B] :
            ( range_16_0(B)
           => ( v7894(VarNext,B)
            <=> v7892(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_135,axiom,
    ! [VarNext] :
      ( v7895(VarNext)
     => ! [B] :
          ( range_16_0(B)
         => ( v7894(VarNext,B)
          <=> v7903(VarNext,B) ) ) ) ).

fof(addAssignment_1831,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_16_0(B)
         => ( v7903(VarNext,B)
          <=> v7901(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_186,axiom,
    ! [VarCurr] :
      ( ~ v7904(VarCurr)
     => ! [B] :
          ( range_16_0(B)
         => ( v7901(VarCurr,B)
          <=> v7889(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_188,axiom,
    ! [VarCurr] :
      ( v7904(VarCurr)
     => ! [B] :
          ( range_16_0(B)
         => ( v7901(VarCurr,B)
          <=> b10000000000000000(B) ) ) ) ).

fof(bitBlastConstant_804,axiom,
    b10000000000000000(bitIndex16) ).

fof(bitBlastConstant_803,axiom,
    ~ b10000000000000000(bitIndex15) ).

fof(bitBlastConstant_802,axiom,
    ~ b10000000000000000(bitIndex14) ).

fof(bitBlastConstant_801,axiom,
    ~ b10000000000000000(bitIndex13) ).

fof(bitBlastConstant_800,axiom,
    ~ b10000000000000000(bitIndex12) ).

fof(bitBlastConstant_799,axiom,
    ~ b10000000000000000(bitIndex11) ).

fof(bitBlastConstant_798,axiom,
    ~ b10000000000000000(bitIndex10) ).

fof(bitBlastConstant_797,axiom,
    ~ b10000000000000000(bitIndex9) ).

fof(bitBlastConstant_796,axiom,
    ~ b10000000000000000(bitIndex8) ).

fof(bitBlastConstant_795,axiom,
    ~ b10000000000000000(bitIndex7) ).

fof(bitBlastConstant_794,axiom,
    ~ b10000000000000000(bitIndex6) ).

fof(bitBlastConstant_793,axiom,
    ~ b10000000000000000(bitIndex5) ).

fof(bitBlastConstant_792,axiom,
    ~ b10000000000000000(bitIndex4) ).

fof(bitBlastConstant_791,axiom,
    ~ b10000000000000000(bitIndex3) ).

fof(bitBlastConstant_790,axiom,
    ~ b10000000000000000(bitIndex2) ).

fof(bitBlastConstant_789,axiom,
    ~ b10000000000000000(bitIndex1) ).

fof(bitBlastConstant_788,axiom,
    ~ b10000000000000000(bitIndex0) ).

fof(writeUnaryOperator_705,axiom,
    ! [VarCurr] :
      ( ~ v7904(VarCurr)
    <=> v5405(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1474,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7895(VarNext)
      <=> v7896(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1473,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7896(VarNext)
      <=> ( v7897(VarNext)
          & v5474(VarNext) ) ) ) ).

fof(writeUnaryOperator_704,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7897(VarNext)
      <=> v5481(VarNext) ) ) ).

fof(addAssignment_1830,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v5282(VarCurr,B)
      <=> v5284(VarCurr,B) ) ) ).

fof(addAssignment_1829,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v5284(VarCurr,B)
      <=> v5286(VarCurr,B) ) ) ).

fof(addAssignment_1828,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v5286(VarCurr,B)
      <=> v5288(VarCurr,B) ) ) ).

fof(addAssignment_1827,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v5288(VarCurr,B)
      <=> v7873(VarCurr,B) ) ) ).

fof(addAssignment_1826,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v7750(VarCurr,B)
      <=> v7752(VarCurr,B) ) ) ).

fof(addAssignment_1825,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v7752(VarCurr,B)
      <=> v7754(VarCurr,B) ) ) ).

fof(addAssignment_1824,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v7754(VarCurr,B)
      <=> v7756(VarCurr,B) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_125,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7759(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v7756(VarNext,B)
            <=> v7756(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_134,axiom,
    ! [VarNext] :
      ( v7759(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v7756(VarNext,B)
          <=> v7777(VarNext,B) ) ) ) ).

fof(addAssignment_1823,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v7777(VarNext,B)
          <=> v7775(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_156,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v7775(VarCurr,B)
          <=> v7778(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_148,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v7775(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_155,axiom,
    ! [VarCurr] :
      ( ~ v7779(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v7778(VarCurr,B)
          <=> v7814(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_147,axiom,
    ! [VarCurr] :
      ( v7779(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v7778(VarCurr,B)
          <=> v7784(VarCurr,B) ) ) ) ).

fof(addAssignment_1822,axiom,
    ! [VarCurr] :
      ( v7814(VarCurr,bitIndex0)
    <=> v7866(VarCurr) ) ).

fof(addAssignment_1821,axiom,
    ! [VarCurr] :
      ( v7814(VarCurr,bitIndex1)
    <=> v7861(VarCurr) ) ).

fof(addAssignment_1820,axiom,
    ! [VarCurr] :
      ( v7814(VarCurr,bitIndex2)
    <=> v7856(VarCurr) ) ).

fof(addAssignment_1819,axiom,
    ! [VarCurr] :
      ( v7814(VarCurr,bitIndex3)
    <=> v7851(VarCurr) ) ).

fof(addAssignment_1818,axiom,
    ! [VarCurr] :
      ( v7814(VarCurr,bitIndex4)
    <=> v7816(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1472,axiom,
    ! [VarCurr] :
      ( v7866(VarCurr)
    <=> ( v7867(VarCurr)
        & v7870(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_355,axiom,
    ! [VarCurr] :
      ( v7870(VarCurr)
    <=> ( v4925(VarCurr,bitIndex33)
        | v4699(VarCurr,bitIndex0) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1471,axiom,
    ! [VarCurr] :
      ( v7867(VarCurr)
    <=> ( v7868(VarCurr)
        | v7869(VarCurr) ) ) ).

fof(writeUnaryOperator_703,axiom,
    ! [VarCurr] :
      ( ~ v7869(VarCurr)
    <=> v4699(VarCurr,bitIndex0) ) ).

fof(writeUnaryOperator_702,axiom,
    ! [VarCurr] :
      ( ~ v7868(VarCurr)
    <=> v4925(VarCurr,bitIndex33) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1470,axiom,
    ! [VarCurr] :
      ( v7861(VarCurr)
    <=> ( v7862(VarCurr)
        & v7865(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1469,axiom,
    ! [VarCurr] :
      ( v7865(VarCurr)
    <=> ( v7825(VarCurr)
        | v7826(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1468,axiom,
    ! [VarCurr] :
      ( v7862(VarCurr)
    <=> ( v7863(VarCurr)
        | v7864(VarCurr) ) ) ).

fof(writeUnaryOperator_701,axiom,
    ! [VarCurr] :
      ( ~ v7864(VarCurr)
    <=> v7826(VarCurr) ) ).

fof(writeUnaryOperator_700,axiom,
    ! [VarCurr] :
      ( ~ v7863(VarCurr)
    <=> v7825(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1467,axiom,
    ! [VarCurr] :
      ( v7856(VarCurr)
    <=> ( v7857(VarCurr)
        & v7860(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1466,axiom,
    ! [VarCurr] :
      ( v7860(VarCurr)
    <=> ( v7823(VarCurr)
        | v7832(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1465,axiom,
    ! [VarCurr] :
      ( v7857(VarCurr)
    <=> ( v7858(VarCurr)
        | v7859(VarCurr) ) ) ).

fof(writeUnaryOperator_699,axiom,
    ! [VarCurr] :
      ( ~ v7859(VarCurr)
    <=> v7832(VarCurr) ) ).

fof(writeUnaryOperator_698,axiom,
    ! [VarCurr] :
      ( ~ v7858(VarCurr)
    <=> v7823(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1464,axiom,
    ! [VarCurr] :
      ( v7851(VarCurr)
    <=> ( v7852(VarCurr)
        & v7855(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1463,axiom,
    ! [VarCurr] :
      ( v7855(VarCurr)
    <=> ( v7821(VarCurr)
        | v7838(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1462,axiom,
    ! [VarCurr] :
      ( v7852(VarCurr)
    <=> ( v7853(VarCurr)
        | v7854(VarCurr) ) ) ).

fof(writeUnaryOperator_697,axiom,
    ! [VarCurr] :
      ( ~ v7854(VarCurr)
    <=> v7838(VarCurr) ) ).

fof(writeUnaryOperator_696,axiom,
    ! [VarCurr] :
      ( ~ v7853(VarCurr)
    <=> v7821(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1461,axiom,
    ! [VarCurr] :
      ( v7816(VarCurr)
    <=> ( v7817(VarCurr)
        & v7850(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1460,axiom,
    ! [VarCurr] :
      ( v7850(VarCurr)
    <=> ( v7819(VarCurr)
        | v7845(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1459,axiom,
    ! [VarCurr] :
      ( v7817(VarCurr)
    <=> ( v7818(VarCurr)
        | v7844(VarCurr) ) ) ).

fof(writeUnaryOperator_695,axiom,
    ! [VarCurr] :
      ( ~ v7844(VarCurr)
    <=> v7845(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1458,axiom,
    ! [VarCurr] :
      ( v7845(VarCurr)
    <=> ( v7846(VarCurr)
        & v7849(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_354,axiom,
    ! [VarCurr] :
      ( v7849(VarCurr)
    <=> ( v4925(VarCurr,bitIndex37)
        | v4699(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1457,axiom,
    ! [VarCurr] :
      ( v7846(VarCurr)
    <=> ( v7847(VarCurr)
        | v7848(VarCurr) ) ) ).

fof(writeUnaryOperator_694,axiom,
    ! [VarCurr] :
      ( ~ v7848(VarCurr)
    <=> v4699(VarCurr,bitIndex4) ) ).

fof(writeUnaryOperator_693,axiom,
    ! [VarCurr] :
      ( ~ v7847(VarCurr)
    <=> v4925(VarCurr,bitIndex37) ) ).

fof(writeUnaryOperator_692,axiom,
    ! [VarCurr] :
      ( ~ v7818(VarCurr)
    <=> v7819(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1456,axiom,
    ! [VarCurr] :
      ( v7819(VarCurr)
    <=> ( v7820(VarCurr)
        | v7843(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_353,axiom,
    ! [VarCurr] :
      ( v7843(VarCurr)
    <=> ( v4925(VarCurr,bitIndex36)
        & v4699(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1455,axiom,
    ! [VarCurr] :
      ( v7820(VarCurr)
    <=> ( v7821(VarCurr)
        & v7838(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1454,axiom,
    ! [VarCurr] :
      ( v7838(VarCurr)
    <=> ( v7839(VarCurr)
        & v7842(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_352,axiom,
    ! [VarCurr] :
      ( v7842(VarCurr)
    <=> ( v4925(VarCurr,bitIndex36)
        | v4699(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1453,axiom,
    ! [VarCurr] :
      ( v7839(VarCurr)
    <=> ( v7840(VarCurr)
        | v7841(VarCurr) ) ) ).

fof(writeUnaryOperator_691,axiom,
    ! [VarCurr] :
      ( ~ v7841(VarCurr)
    <=> v4699(VarCurr,bitIndex3) ) ).

fof(writeUnaryOperator_690,axiom,
    ! [VarCurr] :
      ( ~ v7840(VarCurr)
    <=> v4925(VarCurr,bitIndex36) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1452,axiom,
    ! [VarCurr] :
      ( v7821(VarCurr)
    <=> ( v7822(VarCurr)
        | v7837(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_351,axiom,
    ! [VarCurr] :
      ( v7837(VarCurr)
    <=> ( v4925(VarCurr,bitIndex35)
        & v4699(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1451,axiom,
    ! [VarCurr] :
      ( v7822(VarCurr)
    <=> ( v7823(VarCurr)
        & v7832(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1450,axiom,
    ! [VarCurr] :
      ( v7832(VarCurr)
    <=> ( v7833(VarCurr)
        & v7836(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_350,axiom,
    ! [VarCurr] :
      ( v7836(VarCurr)
    <=> ( v4925(VarCurr,bitIndex35)
        | v4699(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1449,axiom,
    ! [VarCurr] :
      ( v7833(VarCurr)
    <=> ( v7834(VarCurr)
        | v7835(VarCurr) ) ) ).

fof(writeUnaryOperator_689,axiom,
    ! [VarCurr] :
      ( ~ v7835(VarCurr)
    <=> v4699(VarCurr,bitIndex2) ) ).

fof(writeUnaryOperator_688,axiom,
    ! [VarCurr] :
      ( ~ v7834(VarCurr)
    <=> v4925(VarCurr,bitIndex35) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1448,axiom,
    ! [VarCurr] :
      ( v7823(VarCurr)
    <=> ( v7824(VarCurr)
        | v7831(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_349,axiom,
    ! [VarCurr] :
      ( v7831(VarCurr)
    <=> ( v4925(VarCurr,bitIndex34)
        & v4699(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1447,axiom,
    ! [VarCurr] :
      ( v7824(VarCurr)
    <=> ( v7825(VarCurr)
        & v7826(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1446,axiom,
    ! [VarCurr] :
      ( v7826(VarCurr)
    <=> ( v7827(VarCurr)
        & v7830(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_348,axiom,
    ! [VarCurr] :
      ( v7830(VarCurr)
    <=> ( v4925(VarCurr,bitIndex34)
        | v4699(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1445,axiom,
    ! [VarCurr] :
      ( v7827(VarCurr)
    <=> ( v7828(VarCurr)
        | v7829(VarCurr) ) ) ).

fof(writeUnaryOperator_687,axiom,
    ! [VarCurr] :
      ( ~ v7829(VarCurr)
    <=> v4699(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_686,axiom,
    ! [VarCurr] :
      ( ~ v7828(VarCurr)
    <=> v4925(VarCurr,bitIndex34) ) ).

fof(writeBinaryOperatorShiftedRanges_347,axiom,
    ! [VarCurr] :
      ( v7825(VarCurr)
    <=> ( v4925(VarCurr,bitIndex33)
        & v4699(VarCurr,bitIndex0) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1444,axiom,
    ! [VarCurr] :
      ( v7809(VarCurr)
    <=> ( v7810(VarCurr)
        | v7812(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_489,axiom,
    ! [VarCurr] :
      ( v7812(VarCurr)
    <=> ( ( v7813(VarCurr,bitIndex1)
        <=> $false )
        & ( v7813(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1817,axiom,
    ! [VarCurr] :
      ( v7813(VarCurr,bitIndex0)
    <=> v4670(VarCurr) ) ).

fof(addAssignment_1816,axiom,
    ! [VarCurr] :
      ( v7813(VarCurr,bitIndex1)
    <=> v3182(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_488,axiom,
    ! [VarCurr] :
      ( v7810(VarCurr)
    <=> ( ( v7811(VarCurr,bitIndex1)
        <=> $false )
        & ( v7811(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1815,axiom,
    ! [VarCurr] :
      ( v7811(VarCurr,bitIndex0)
    <=> v4670(VarCurr) ) ).

fof(addAssignment_1814,axiom,
    ! [VarCurr] :
      ( v7811(VarCurr,bitIndex1)
    <=> v3182(VarCurr) ) ).

fof(addAssignment_1813,axiom,
    ! [VarCurr] :
      ( v7784(VarCurr,bitIndex0)
    <=> v7806(VarCurr) ) ).

fof(addAssignment_1812,axiom,
    ! [VarCurr] :
      ( v7784(VarCurr,bitIndex1)
    <=> v7804(VarCurr) ) ).

fof(addAssignment_1811,axiom,
    ! [VarCurr] :
      ( v7784(VarCurr,bitIndex2)
    <=> v7799(VarCurr) ) ).

fof(addAssignment_1810,axiom,
    ! [VarCurr] :
      ( v7784(VarCurr,bitIndex3)
    <=> v7794(VarCurr) ) ).

fof(addAssignment_1809,axiom,
    ! [VarCurr] :
      ( v7784(VarCurr,bitIndex4)
    <=> v7786(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1443,axiom,
    ! [VarCurr] :
      ( v7804(VarCurr)
    <=> ( v7805(VarCurr)
        & v7808(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_346,axiom,
    ! [VarCurr] :
      ( v7808(VarCurr)
    <=> ( v7756(VarCurr,bitIndex0)
        | v7756(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1442,axiom,
    ! [VarCurr] :
      ( v7805(VarCurr)
    <=> ( v7806(VarCurr)
        | v7807(VarCurr) ) ) ).

fof(writeUnaryOperator_685,axiom,
    ! [VarCurr] :
      ( ~ v7807(VarCurr)
    <=> v7756(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_684,axiom,
    ! [VarCurr] :
      ( ~ v7806(VarCurr)
    <=> v7756(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1441,axiom,
    ! [VarCurr] :
      ( v7799(VarCurr)
    <=> ( v7800(VarCurr)
        & v7803(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_345,axiom,
    ! [VarCurr] :
      ( v7803(VarCurr)
    <=> ( v7791(VarCurr)
        | v7756(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1440,axiom,
    ! [VarCurr] :
      ( v7800(VarCurr)
    <=> ( v7801(VarCurr)
        | v7802(VarCurr) ) ) ).

fof(writeUnaryOperator_683,axiom,
    ! [VarCurr] :
      ( ~ v7802(VarCurr)
    <=> v7756(VarCurr,bitIndex2) ) ).

fof(writeUnaryOperator_682,axiom,
    ! [VarCurr] :
      ( ~ v7801(VarCurr)
    <=> v7791(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1439,axiom,
    ! [VarCurr] :
      ( v7794(VarCurr)
    <=> ( v7795(VarCurr)
        & v7798(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_344,axiom,
    ! [VarCurr] :
      ( v7798(VarCurr)
    <=> ( v7790(VarCurr)
        | v7756(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1438,axiom,
    ! [VarCurr] :
      ( v7795(VarCurr)
    <=> ( v7796(VarCurr)
        | v7797(VarCurr) ) ) ).

fof(writeUnaryOperator_681,axiom,
    ! [VarCurr] :
      ( ~ v7797(VarCurr)
    <=> v7756(VarCurr,bitIndex3) ) ).

fof(writeUnaryOperator_680,axiom,
    ! [VarCurr] :
      ( ~ v7796(VarCurr)
    <=> v7790(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1437,axiom,
    ! [VarCurr] :
      ( v7786(VarCurr)
    <=> ( v7787(VarCurr)
        & v7793(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_343,axiom,
    ! [VarCurr] :
      ( v7793(VarCurr)
    <=> ( v7789(VarCurr)
        | v7756(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1436,axiom,
    ! [VarCurr] :
      ( v7787(VarCurr)
    <=> ( v7788(VarCurr)
        | v7792(VarCurr) ) ) ).

fof(writeUnaryOperator_679,axiom,
    ! [VarCurr] :
      ( ~ v7792(VarCurr)
    <=> v7756(VarCurr,bitIndex4) ) ).

fof(writeUnaryOperator_678,axiom,
    ! [VarCurr] :
      ( ~ v7788(VarCurr)
    <=> v7789(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_342,axiom,
    ! [VarCurr] :
      ( v7789(VarCurr)
    <=> ( v7790(VarCurr)
        & v7756(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_341,axiom,
    ! [VarCurr] :
      ( v7790(VarCurr)
    <=> ( v7791(VarCurr)
        & v7756(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_340,axiom,
    ! [VarCurr] :
      ( v7791(VarCurr)
    <=> ( v7756(VarCurr,bitIndex0)
        & v7756(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1435,axiom,
    ! [VarCurr] :
      ( v7779(VarCurr)
    <=> ( v7780(VarCurr)
        | v7782(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_487,axiom,
    ! [VarCurr] :
      ( v7782(VarCurr)
    <=> ( ( v7783(VarCurr,bitIndex1)
        <=> $true )
        & ( v7783(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1808,axiom,
    ! [VarCurr] :
      ( v7783(VarCurr,bitIndex0)
    <=> v4670(VarCurr) ) ).

fof(addAssignment_1807,axiom,
    ! [VarCurr] :
      ( v7783(VarCurr,bitIndex1)
    <=> v3182(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_486,axiom,
    ! [VarCurr] :
      ( v7780(VarCurr)
    <=> ( ( v7781(VarCurr,bitIndex1)
        <=> $true )
        & ( v7781(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1806,axiom,
    ! [VarCurr] :
      ( v7781(VarCurr,bitIndex0)
    <=> v4670(VarCurr) ) ).

fof(addAssignment_1805,axiom,
    ! [VarCurr] :
      ( v7781(VarCurr,bitIndex1)
    <=> v3182(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1434,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7759(VarNext)
      <=> ( v7760(VarNext)
          & v7767(VarNext) ) ) ) ).

fof(addAssignment_1804,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7767(VarNext)
      <=> v7765(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1433,axiom,
    ! [VarCurr] :
      ( v7765(VarCurr)
    <=> ( v7768(VarCurr)
        & v7772(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1432,axiom,
    ! [VarCurr] :
      ( v7772(VarCurr)
    <=> ( v7773(VarCurr)
        | v5397(VarCurr) ) ) ).

fof(writeUnaryOperator_677,axiom,
    ! [VarCurr] :
      ( ~ v7773(VarCurr)
    <=> v7774(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_485,axiom,
    ! [VarCurr] :
      ( v7774(VarCurr)
    <=> ( v5621(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1431,axiom,
    ! [VarCurr] :
      ( v7768(VarCurr)
    <=> ( v5397(VarCurr)
        | v7769(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1430,axiom,
    ! [VarCurr] :
      ( v7769(VarCurr)
    <=> ( v7770(VarCurr)
        & v7771(VarCurr) ) ) ).

fof(writeUnaryOperator_676,axiom,
    ! [VarCurr] :
      ( ~ v7771(VarCurr)
    <=> v5397(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_484,axiom,
    ! [VarCurr] :
      ( v7770(VarCurr)
    <=> ( v5621(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1429,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7760(VarNext)
      <=> ( v7762(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_675,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7762(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValueVector_35,axiom,
    ! [B] :
      ( range_4_0(B)
     => ( v7756(constB0,B)
      <=> $false ) ) ).

fof(addCaseBooleanConditionEqualRanges1_124,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7738(VarNext)
       => ( v5619(VarNext)
        <=> v5619(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_133,axiom,
    ! [VarNext] :
      ( v7738(VarNext)
     => ( v5619(VarNext)
      <=> v7746(VarNext) ) ) ).

fof(addAssignment_1803,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7746(VarNext)
      <=> v7744(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_185,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ( v7744(VarCurr)
      <=> v5621(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_187,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ( v7744(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1428,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7738(VarNext)
      <=> v7739(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1427,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7739(VarNext)
      <=> ( v7741(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_674,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7741(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValueVector_34,axiom,
    ( v5619(constB0)
  <=> $false ) ).

fof(addParallelCaseBooleanConditionEqualRanges5_3,axiom,
    ! [VarCurr] :
      ( ( ~ v5338(VarCurr)
        & ~ v5339(VarCurr)
        & ~ v5340(VarCurr)
        & ~ v5341(VarCurr)
        & ~ v5353(VarCurr) )
     => ( v5621(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges4_4,axiom,
    ! [VarCurr] :
      ( v5353(VarCurr)
     => ( v5621(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_28,axiom,
    ! [VarCurr] :
      ( v5341(VarCurr)
     => ( v5621(VarCurr)
      <=> v7733(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_63,axiom,
    ! [VarCurr] :
      ( v5340(VarCurr)
     => ( v5621(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_154,axiom,
    ! [VarCurr] :
      ( v5339(VarCurr)
     => ( v5621(VarCurr)
      <=> v7729(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_146,axiom,
    ! [VarCurr] :
      ( v5338(VarCurr)
     => ( v5621(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_153,axiom,
    ! [VarCurr] :
      ( ~ v5343(VarCurr)
     => ( v7733(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_145,axiom,
    ! [VarCurr] :
      ( v5343(VarCurr)
     => ( v7733(VarCurr)
      <=> v7734(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_152,axiom,
    ! [VarCurr] :
      ( ~ v7735(VarCurr)
     => ( v7734(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_144,axiom,
    ! [VarCurr] :
      ( v7735(VarCurr)
     => ( v7734(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1426,axiom,
    ! [VarCurr] :
      ( v7735(VarCurr)
    <=> ( v5345(VarCurr)
        | v5347(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_151,axiom,
    ! [VarCurr] :
      ( ~ v6292(VarCurr)
     => ( v7729(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_143,axiom,
    ! [VarCurr] :
      ( v6292(VarCurr)
     => ( v7729(VarCurr)
      <=> v7730(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_150,axiom,
    ! [VarCurr] :
      ( ~ v7731(VarCurr)
     => ( v7730(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_142,axiom,
    ! [VarCurr] :
      ( v7731(VarCurr)
     => ( v7730(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_483,axiom,
    ! [VarCurr] :
      ( v7732(VarCurr)
    <=> ( v5623(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_482,axiom,
    ! [VarCurr] :
      ( v7731(VarCurr)
    <=> ( v5623(VarCurr)
      <=> $true ) ) ).

fof(addCaseBooleanConditionEqualRanges1_123,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7621(VarNext)
       => ( v5623(VarNext)
        <=> v5623(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_132,axiom,
    ! [VarNext] :
      ( v7621(VarNext)
     => ( v5623(VarNext)
      <=> v7637(VarNext) ) ) ).

fof(addAssignment_1802,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7637(VarNext)
      <=> v7635(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_184,axiom,
    ! [VarCurr] :
      ( ~ v7634(VarCurr)
     => ( v7635(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_186,axiom,
    ! [VarCurr] :
      ( v7634(VarCurr)
     => ( v7635(VarCurr)
      <=> v7638(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_481,axiom,
    ! [VarCurr] :
      ( v7638(VarCurr)
    <=> ( ( v7639(VarCurr,bitIndex5)
        <=> $false )
        & ( v7639(VarCurr,bitIndex4)
        <=> $false )
        & ( v7639(VarCurr,bitIndex3)
        <=> $false )
        & ( v7639(VarCurr,bitIndex2)
        <=> $false )
        & ( v7639(VarCurr,bitIndex1)
        <=> $false )
        & ( v7639(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1801,axiom,
    ! [VarCurr] :
      ( v7639(VarCurr,bitIndex0)
    <=> v7723(VarCurr) ) ).

fof(addAssignment_1800,axiom,
    ! [VarCurr] :
      ( v7639(VarCurr,bitIndex1)
    <=> v7718(VarCurr) ) ).

fof(addAssignment_1799,axiom,
    ! [VarCurr] :
      ( v7639(VarCurr,bitIndex2)
    <=> v7713(VarCurr) ) ).

fof(addAssignment_1798,axiom,
    ! [VarCurr] :
      ( v7639(VarCurr,bitIndex3)
    <=> v7708(VarCurr) ) ).

fof(addAssignment_1797,axiom,
    ! [VarCurr] :
      ( v7639(VarCurr,bitIndex4)
    <=> v7703(VarCurr) ) ).

fof(addAssignment_1796,axiom,
    ! [VarCurr] :
      ( v7639(VarCurr,bitIndex5)
    <=> v7641(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1425,axiom,
    ! [VarCurr] :
      ( v7723(VarCurr)
    <=> ( v7724(VarCurr)
        & v7725(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_339,axiom,
    ! [VarCurr] :
      ( v7725(VarCurr)
    <=> ( v5625(VarCurr,bitIndex38)
        | v6551(VarCurr,bitIndex0) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1424,axiom,
    ! [VarCurr] :
      ( v7724(VarCurr)
    <=> ( v6737(VarCurr)
        | v7659(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1423,axiom,
    ! [VarCurr] :
      ( v7718(VarCurr)
    <=> ( v7719(VarCurr)
        & v7722(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1422,axiom,
    ! [VarCurr] :
      ( v7722(VarCurr)
    <=> ( v7652(VarCurr)
        | v7653(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1421,axiom,
    ! [VarCurr] :
      ( v7719(VarCurr)
    <=> ( v7720(VarCurr)
        | v7721(VarCurr) ) ) ).

fof(writeUnaryOperator_673,axiom,
    ! [VarCurr] :
      ( ~ v7721(VarCurr)
    <=> v7653(VarCurr) ) ).

fof(writeUnaryOperator_672,axiom,
    ! [VarCurr] :
      ( ~ v7720(VarCurr)
    <=> v7652(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1420,axiom,
    ! [VarCurr] :
      ( v7713(VarCurr)
    <=> ( v7714(VarCurr)
        & v7717(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1419,axiom,
    ! [VarCurr] :
      ( v7717(VarCurr)
    <=> ( v7650(VarCurr)
        | v7663(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1418,axiom,
    ! [VarCurr] :
      ( v7714(VarCurr)
    <=> ( v7715(VarCurr)
        | v7716(VarCurr) ) ) ).

fof(writeUnaryOperator_671,axiom,
    ! [VarCurr] :
      ( ~ v7716(VarCurr)
    <=> v7663(VarCurr) ) ).

fof(writeUnaryOperator_670,axiom,
    ! [VarCurr] :
      ( ~ v7715(VarCurr)
    <=> v7650(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1417,axiom,
    ! [VarCurr] :
      ( v7708(VarCurr)
    <=> ( v7709(VarCurr)
        & v7712(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1416,axiom,
    ! [VarCurr] :
      ( v7712(VarCurr)
    <=> ( v7648(VarCurr)
        | v7674(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1415,axiom,
    ! [VarCurr] :
      ( v7709(VarCurr)
    <=> ( v7710(VarCurr)
        | v7711(VarCurr) ) ) ).

fof(writeUnaryOperator_669,axiom,
    ! [VarCurr] :
      ( ~ v7711(VarCurr)
    <=> v7674(VarCurr) ) ).

fof(writeUnaryOperator_668,axiom,
    ! [VarCurr] :
      ( ~ v7710(VarCurr)
    <=> v7648(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1414,axiom,
    ! [VarCurr] :
      ( v7703(VarCurr)
    <=> ( v7704(VarCurr)
        & v7707(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1413,axiom,
    ! [VarCurr] :
      ( v7707(VarCurr)
    <=> ( v7646(VarCurr)
        | v7685(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1412,axiom,
    ! [VarCurr] :
      ( v7704(VarCurr)
    <=> ( v7705(VarCurr)
        | v7706(VarCurr) ) ) ).

fof(writeUnaryOperator_667,axiom,
    ! [VarCurr] :
      ( ~ v7706(VarCurr)
    <=> v7685(VarCurr) ) ).

fof(writeUnaryOperator_666,axiom,
    ! [VarCurr] :
      ( ~ v7705(VarCurr)
    <=> v7646(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1411,axiom,
    ! [VarCurr] :
      ( v7641(VarCurr)
    <=> ( v7642(VarCurr)
        & v7702(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1410,axiom,
    ! [VarCurr] :
      ( v7702(VarCurr)
    <=> ( v7644(VarCurr)
        | v7697(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1409,axiom,
    ! [VarCurr] :
      ( v7642(VarCurr)
    <=> ( v7643(VarCurr)
        | v7696(VarCurr) ) ) ).

fof(writeUnaryOperator_665,axiom,
    ! [VarCurr] :
      ( ~ v7696(VarCurr)
    <=> v7697(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1408,axiom,
    ! [VarCurr] :
      ( v7697(VarCurr)
    <=> ( v7698(VarCurr)
        & v7700(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_338,axiom,
    ! [VarCurr] :
      ( v7700(VarCurr)
    <=> ( v5625(VarCurr,bitIndex43)
        | v7701(VarCurr) ) ) ).

fof(writeUnaryOperator_664,axiom,
    ! [VarCurr] :
      ( ~ v7701(VarCurr)
    <=> v7699(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1407,axiom,
    ! [VarCurr] :
      ( v7698(VarCurr)
    <=> ( v6711(VarCurr)
        | v7699(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1406,axiom,
    ! [VarCurr] :
      ( v7699(VarCurr)
    <=> ( v7691(VarCurr)
        & v7693(VarCurr) ) ) ).

fof(writeUnaryOperator_663,axiom,
    ! [VarCurr] :
      ( ~ v7643(VarCurr)
    <=> v7644(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1405,axiom,
    ! [VarCurr] :
      ( v7644(VarCurr)
    <=> ( v7645(VarCurr)
        | v7695(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_337,axiom,
    ! [VarCurr] :
      ( v7695(VarCurr)
    <=> ( v5625(VarCurr,bitIndex42)
        & v7688(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1404,axiom,
    ! [VarCurr] :
      ( v7645(VarCurr)
    <=> ( v7646(VarCurr)
        & v7685(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1403,axiom,
    ! [VarCurr] :
      ( v7685(VarCurr)
    <=> ( v7686(VarCurr)
        & v7694(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_336,axiom,
    ! [VarCurr] :
      ( v7694(VarCurr)
    <=> ( v5625(VarCurr,bitIndex42)
        | v7688(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1402,axiom,
    ! [VarCurr] :
      ( v7686(VarCurr)
    <=> ( v6704(VarCurr)
        | v7687(VarCurr) ) ) ).

fof(writeUnaryOperator_662,axiom,
    ! [VarCurr] :
      ( ~ v7687(VarCurr)
    <=> v7688(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1401,axiom,
    ! [VarCurr] :
      ( v7688(VarCurr)
    <=> ( v7689(VarCurr)
        & v7692(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1400,axiom,
    ! [VarCurr] :
      ( v7692(VarCurr)
    <=> ( v7691(VarCurr)
        | v7693(VarCurr) ) ) ).

fof(writeUnaryOperator_661,axiom,
    ! [VarCurr] :
      ( ~ v7693(VarCurr)
    <=> v6551(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_335,axiom,
    ! [VarCurr] :
      ( v7689(VarCurr)
    <=> ( v7690(VarCurr)
        | v6551(VarCurr,bitIndex4) ) ) ).

fof(writeUnaryOperator_660,axiom,
    ! [VarCurr] :
      ( ~ v7690(VarCurr)
    <=> v7691(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1399,axiom,
    ! [VarCurr] :
      ( v7691(VarCurr)
    <=> ( v7680(VarCurr)
        & v7682(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1398,axiom,
    ! [VarCurr] :
      ( v7646(VarCurr)
    <=> ( v7647(VarCurr)
        | v7684(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_334,axiom,
    ! [VarCurr] :
      ( v7684(VarCurr)
    <=> ( v5625(VarCurr,bitIndex41)
        & v7677(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1397,axiom,
    ! [VarCurr] :
      ( v7647(VarCurr)
    <=> ( v7648(VarCurr)
        & v7674(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1396,axiom,
    ! [VarCurr] :
      ( v7674(VarCurr)
    <=> ( v7675(VarCurr)
        & v7683(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_333,axiom,
    ! [VarCurr] :
      ( v7683(VarCurr)
    <=> ( v5625(VarCurr,bitIndex41)
        | v7677(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1395,axiom,
    ! [VarCurr] :
      ( v7675(VarCurr)
    <=> ( v6692(VarCurr)
        | v7676(VarCurr) ) ) ).

fof(writeUnaryOperator_659,axiom,
    ! [VarCurr] :
      ( ~ v7676(VarCurr)
    <=> v7677(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1394,axiom,
    ! [VarCurr] :
      ( v7677(VarCurr)
    <=> ( v7678(VarCurr)
        & v7681(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1393,axiom,
    ! [VarCurr] :
      ( v7681(VarCurr)
    <=> ( v7680(VarCurr)
        | v7682(VarCurr) ) ) ).

fof(writeUnaryOperator_658,axiom,
    ! [VarCurr] :
      ( ~ v7682(VarCurr)
    <=> v6551(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_332,axiom,
    ! [VarCurr] :
      ( v7678(VarCurr)
    <=> ( v7679(VarCurr)
        | v6551(VarCurr,bitIndex3) ) ) ).

fof(writeUnaryOperator_657,axiom,
    ! [VarCurr] :
      ( ~ v7679(VarCurr)
    <=> v7680(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1392,axiom,
    ! [VarCurr] :
      ( v7680(VarCurr)
    <=> ( v7669(VarCurr)
        & v7671(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1391,axiom,
    ! [VarCurr] :
      ( v7648(VarCurr)
    <=> ( v7649(VarCurr)
        | v7673(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_331,axiom,
    ! [VarCurr] :
      ( v7673(VarCurr)
    <=> ( v5625(VarCurr,bitIndex40)
        & v7666(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1390,axiom,
    ! [VarCurr] :
      ( v7649(VarCurr)
    <=> ( v7650(VarCurr)
        & v7663(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1389,axiom,
    ! [VarCurr] :
      ( v7663(VarCurr)
    <=> ( v7664(VarCurr)
        & v7672(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_330,axiom,
    ! [VarCurr] :
      ( v7672(VarCurr)
    <=> ( v5625(VarCurr,bitIndex40)
        | v7666(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1388,axiom,
    ! [VarCurr] :
      ( v7664(VarCurr)
    <=> ( v6680(VarCurr)
        | v7665(VarCurr) ) ) ).

fof(writeUnaryOperator_656,axiom,
    ! [VarCurr] :
      ( ~ v7665(VarCurr)
    <=> v7666(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1387,axiom,
    ! [VarCurr] :
      ( v7666(VarCurr)
    <=> ( v7667(VarCurr)
        & v7670(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1386,axiom,
    ! [VarCurr] :
      ( v7670(VarCurr)
    <=> ( v7669(VarCurr)
        | v7671(VarCurr) ) ) ).

fof(writeUnaryOperator_655,axiom,
    ! [VarCurr] :
      ( ~ v7671(VarCurr)
    <=> v6551(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges_329,axiom,
    ! [VarCurr] :
      ( v7667(VarCurr)
    <=> ( v7668(VarCurr)
        | v6551(VarCurr,bitIndex2) ) ) ).

fof(writeUnaryOperator_654,axiom,
    ! [VarCurr] :
      ( ~ v7668(VarCurr)
    <=> v7669(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1385,axiom,
    ! [VarCurr] :
      ( v7669(VarCurr)
    <=> ( v7659(VarCurr)
        & v7660(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1384,axiom,
    ! [VarCurr] :
      ( v7650(VarCurr)
    <=> ( v7651(VarCurr)
        | v7662(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_328,axiom,
    ! [VarCurr] :
      ( v7662(VarCurr)
    <=> ( v5625(VarCurr,bitIndex39)
        & v7656(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1383,axiom,
    ! [VarCurr] :
      ( v7651(VarCurr)
    <=> ( v7652(VarCurr)
        & v7653(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1382,axiom,
    ! [VarCurr] :
      ( v7653(VarCurr)
    <=> ( v7654(VarCurr)
        & v7661(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_327,axiom,
    ! [VarCurr] :
      ( v7661(VarCurr)
    <=> ( v5625(VarCurr,bitIndex39)
        | v7656(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1381,axiom,
    ! [VarCurr] :
      ( v7654(VarCurr)
    <=> ( v6668(VarCurr)
        | v7655(VarCurr) ) ) ).

fof(writeUnaryOperator_653,axiom,
    ! [VarCurr] :
      ( ~ v7655(VarCurr)
    <=> v7656(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1380,axiom,
    ! [VarCurr] :
      ( v7656(VarCurr)
    <=> ( v7657(VarCurr)
        & v7658(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1379,axiom,
    ! [VarCurr] :
      ( v7658(VarCurr)
    <=> ( v7659(VarCurr)
        | v7660(VarCurr) ) ) ).

fof(writeUnaryOperator_652,axiom,
    ! [VarCurr] :
      ( ~ v7660(VarCurr)
    <=> v6551(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_651,axiom,
    ! [VarCurr] :
      ( ~ v7659(VarCurr)
    <=> v6551(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorShiftedRanges_326,axiom,
    ! [VarCurr] :
      ( v7657(VarCurr)
    <=> ( v6551(VarCurr,bitIndex0)
        | v6551(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorShiftedRanges_325,axiom,
    ! [VarCurr] :
      ( v7652(VarCurr)
    <=> ( v5625(VarCurr,bitIndex38)
        & v6551(VarCurr,bitIndex0) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1378,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7621(VarNext)
      <=> ( v7622(VarNext)
          & v7629(VarNext) ) ) ) ).

fof(addAssignment_1795,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7629(VarNext)
      <=> v7627(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1377,axiom,
    ! [VarCurr] :
      ( v7627(VarCurr)
    <=> ( v7630(VarCurr)
        & v7631(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1376,axiom,
    ! [VarCurr] :
      ( v7631(VarCurr)
    <=> ( v7632(VarCurr)
        | v5397(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1375,axiom,
    ! [VarCurr] :
      ( v7632(VarCurr)
    <=> ( v5278(VarCurr)
        | v7633(VarCurr) ) ) ).

fof(writeUnaryOperator_650,axiom,
    ! [VarCurr] :
      ( ~ v7633(VarCurr)
    <=> v7634(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_480,axiom,
    ! [VarCurr] :
      ( v7634(VarCurr)
    <=> ( v3182(VarCurr)
      <=> $true ) ) ).

fof(writeUnaryOperator_649,axiom,
    ! [VarCurr] :
      ( ~ v7630(VarCurr)
    <=> v5397(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1374,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7622(VarNext)
      <=> ( v7624(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_648,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7624(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValueVector_33,axiom,
    ( v5623(constB0)
  <=> $false ) ).

fof(addAssignment_1794,axiom,
    ! [VarCurr,B] :
      ( range_43_38(B)
     => ( v4925(VarCurr,B)
      <=> v4927(VarCurr,B) ) ) ).

fof(addAssignment_1793,axiom,
    ! [VarCurr,B] :
      ( range_43_38(B)
     => ( v4927(VarCurr,B)
      <=> v4929(VarCurr,B) ) ) ).

fof(addAssignment_1792,axiom,
    ! [VarCurr,B] :
      ( range_43_38(B)
     => ( v4929(VarCurr,B)
      <=> v4931(VarCurr,B) ) ) ).

fof(addAssignment_1791,axiom,
    ! [VarCurr,B] :
      ( range_43_38(B)
     => ( v4931(VarCurr,B)
      <=> v6529(VarCurr,B) ) ) ).

fof(range_axiom_48,axiom,
    ! [B] :
      ( range_43_38(B)
    <=> ( $false
        | bitIndex38 = B
        | bitIndex39 = B
        | bitIndex40 = B
        | bitIndex41 = B
        | bitIndex42 = B
        | bitIndex43 = B ) ) ).

fof(memoryReadIntoBuffer_53,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00000_address_term = A
             => ( range_43_0(B)
               => ( v7327(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_52,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00001_address_term = A
             => ( range_43_0(B)
               => ( v7336(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_51,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00010_address_term = A
             => ( range_43_0(B)
               => ( v7345(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_50,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00011_address_term = A
             => ( range_43_0(B)
               => ( v7354(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_49,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00100_address_term = A
             => ( range_43_0(B)
               => ( v7363(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_48,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00101_address_term = A
             => ( range_43_0(B)
               => ( v7372(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_47,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00110_address_term = A
             => ( range_43_0(B)
               => ( v7381(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_46,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b00111_address_term = A
             => ( range_43_0(B)
               => ( v7390(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_45,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01000_address_term = A
             => ( range_43_0(B)
               => ( v7399(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_44,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01001_address_term = A
             => ( range_43_0(B)
               => ( v7408(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_43,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01010_address_term = A
             => ( range_43_0(B)
               => ( v7417(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_42,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01011_address_term = A
             => ( range_43_0(B)
               => ( v7426(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_41,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01100_address_term = A
             => ( range_43_0(B)
               => ( v7435(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_40,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01101_address_term = A
             => ( range_43_0(B)
               => ( v7444(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_39,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01110_address_term = A
             => ( range_43_0(B)
               => ( v7453(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_38,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b01111_address_term = A
             => ( range_43_0(B)
               => ( v7462(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_37,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10000_address_term = A
             => ( range_43_0(B)
               => ( v7471(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_36,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10001_address_term = A
             => ( range_43_0(B)
               => ( v7480(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_35,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10010_address_term = A
             => ( range_43_0(B)
               => ( v7489(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_34,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10011_address_term = A
             => ( range_43_0(B)
               => ( v7498(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_33,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10100_address_term = A
             => ( range_43_0(B)
               => ( v7507(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_32,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10101_address_term = A
             => ( range_43_0(B)
               => ( v7516(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_31,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10110_address_term = A
             => ( range_43_0(B)
               => ( v7525(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_30,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b10111_address_term = A
             => ( range_43_0(B)
               => ( v7534(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_29,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11000_address_term = A
             => ( range_43_0(B)
               => ( v7543(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_28,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11001_address_term = A
             => ( range_43_0(B)
               => ( v7552(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_27,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11010_address_term = A
             => ( range_43_0(B)
               => ( v7561(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_26,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11011_address_term = A
             => ( range_43_0(B)
               => ( v7570(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_25,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11100_address_term = A
             => ( range_43_0(B)
               => ( v7579(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_24,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11101_address_term = A
             => ( range_43_0(B)
               => ( v7588(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_23,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11110_address_term = A
             => ( range_43_0(B)
               => ( v7597(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_22,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b11111_address_term = A
             => ( range_43_0(B)
               => ( v7606(VarNext,B)
                <=> v4933_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_21,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v6281_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( address(A)
             => ! [B] :
                  ( A = AssociatedAddressVar
                 => ( range_43_0(B)
                   => ( v6529(VarNext,B)
                    <=> v4933_array(VarNext,A,B) ) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_20,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v6241_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( address(A)
             => ! [B] :
                  ( A = AssociatedAddressVar
                 => ( range_43_0(B)
                   => ( v7617(VarNext,B)
                    <=> v4933_array(VarNext,A,B) ) ) ) ) ) ) ).

fof(memoryConstantWriteDisabled_4,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( $true
              & v7609(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_array(VarNext,A,B)
              <=> v4933_36__array(VarNext,A,B) ) ) ) ) ).

fof(memoryConstantWriteEnabledInsideRange_4,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( $true
            & v7609(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_array(VarNext,A,B)
              <=> b00000000000000000000000000000000000000000000(B) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1373,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7609(VarNext)
      <=> ( v7610(VarNext)
          & v7615(VarNext) ) ) ) ).

fof(addAssignment_1790,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7615(VarNext)
      <=> v7280(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1372,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7610(VarNext)
      <=> ( v7612(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_647,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7612(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_55,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11111_address_term = A
              & v7600(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_36__array(VarNext,A,B)
              <=> v4933_35__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_55,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11111_address_term = A
            & v7600(VarNext) )
         => ( ( v4933_36__array(VarNext,A,bitIndex43)
            <=> v7606(VarNext,bitIndex1407) )
            & ( v4933_36__array(VarNext,A,bitIndex42)
            <=> v7606(VarNext,bitIndex1406) )
            & ( v4933_36__array(VarNext,A,bitIndex41)
            <=> v7606(VarNext,bitIndex1405) )
            & ( v4933_36__array(VarNext,A,bitIndex40)
            <=> v7606(VarNext,bitIndex1404) )
            & ( v4933_36__array(VarNext,A,bitIndex39)
            <=> v7606(VarNext,bitIndex1403) )
            & ( v4933_36__array(VarNext,A,bitIndex38)
            <=> v7606(VarNext,bitIndex1402) )
            & ( v4933_36__array(VarNext,A,bitIndex37)
            <=> v7606(VarNext,bitIndex1401) )
            & ( v4933_36__array(VarNext,A,bitIndex36)
            <=> v7606(VarNext,bitIndex1400) )
            & ( v4933_36__array(VarNext,A,bitIndex35)
            <=> v7606(VarNext,bitIndex1399) )
            & ( v4933_36__array(VarNext,A,bitIndex34)
            <=> v7606(VarNext,bitIndex1398) )
            & ( v4933_36__array(VarNext,A,bitIndex33)
            <=> v7606(VarNext,bitIndex1397) )
            & ( v4933_36__array(VarNext,A,bitIndex32)
            <=> v7606(VarNext,bitIndex1396) )
            & ( v4933_36__array(VarNext,A,bitIndex31)
            <=> v7606(VarNext,bitIndex1395) )
            & ( v4933_36__array(VarNext,A,bitIndex30)
            <=> v7606(VarNext,bitIndex1394) )
            & ( v4933_36__array(VarNext,A,bitIndex29)
            <=> v7606(VarNext,bitIndex1393) )
            & ( v4933_36__array(VarNext,A,bitIndex28)
            <=> v7606(VarNext,bitIndex1392) )
            & ( v4933_36__array(VarNext,A,bitIndex27)
            <=> v7606(VarNext,bitIndex1391) )
            & ( v4933_36__array(VarNext,A,bitIndex26)
            <=> v7606(VarNext,bitIndex1390) )
            & ( v4933_36__array(VarNext,A,bitIndex25)
            <=> v7606(VarNext,bitIndex1389) )
            & ( v4933_36__array(VarNext,A,bitIndex24)
            <=> v7606(VarNext,bitIndex1388) )
            & ( v4933_36__array(VarNext,A,bitIndex23)
            <=> v7606(VarNext,bitIndex1387) )
            & ( v4933_36__array(VarNext,A,bitIndex22)
            <=> v7606(VarNext,bitIndex1386) )
            & ( v4933_36__array(VarNext,A,bitIndex21)
            <=> v7606(VarNext,bitIndex1385) )
            & ( v4933_36__array(VarNext,A,bitIndex20)
            <=> v7606(VarNext,bitIndex1384) )
            & ( v4933_36__array(VarNext,A,bitIndex19)
            <=> v7606(VarNext,bitIndex1383) )
            & ( v4933_36__array(VarNext,A,bitIndex18)
            <=> v7606(VarNext,bitIndex1382) )
            & ( v4933_36__array(VarNext,A,bitIndex17)
            <=> v7606(VarNext,bitIndex1381) )
            & ( v4933_36__array(VarNext,A,bitIndex16)
            <=> v7606(VarNext,bitIndex1380) )
            & ( v4933_36__array(VarNext,A,bitIndex15)
            <=> v7606(VarNext,bitIndex1379) )
            & ( v4933_36__array(VarNext,A,bitIndex14)
            <=> v7606(VarNext,bitIndex1378) )
            & ( v4933_36__array(VarNext,A,bitIndex13)
            <=> v7606(VarNext,bitIndex1377) )
            & ( v4933_36__array(VarNext,A,bitIndex12)
            <=> v7606(VarNext,bitIndex1376) )
            & ( v4933_36__array(VarNext,A,bitIndex11)
            <=> v7606(VarNext,bitIndex1375) )
            & ( v4933_36__array(VarNext,A,bitIndex10)
            <=> v7606(VarNext,bitIndex1374) )
            & ( v4933_36__array(VarNext,A,bitIndex9)
            <=> v7606(VarNext,bitIndex1373) )
            & ( v4933_36__array(VarNext,A,bitIndex8)
            <=> v7606(VarNext,bitIndex1372) )
            & ( v4933_36__array(VarNext,A,bitIndex7)
            <=> v7606(VarNext,bitIndex1371) )
            & ( v4933_36__array(VarNext,A,bitIndex6)
            <=> v7606(VarNext,bitIndex1370) )
            & ( v4933_36__array(VarNext,A,bitIndex5)
            <=> v7606(VarNext,bitIndex1369) )
            & ( v4933_36__array(VarNext,A,bitIndex4)
            <=> v7606(VarNext,bitIndex1368) )
            & ( v4933_36__array(VarNext,A,bitIndex3)
            <=> v7606(VarNext,bitIndex1367) )
            & ( v4933_36__array(VarNext,A,bitIndex2)
            <=> v7606(VarNext,bitIndex1366) )
            & ( v4933_36__array(VarNext,A,bitIndex1)
            <=> v7606(VarNext,bitIndex1365) )
            & ( v4933_36__array(VarNext,A,bitIndex0)
            <=> v7606(VarNext,bitIndex1364) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1371,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7600(VarNext)
      <=> ( v7601(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1370,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7601(VarNext)
      <=> ( v7603(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_646,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7603(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_54,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11110_address_term = A
              & v7591(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_35__array(VarNext,A,B)
              <=> v4933_34__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_54,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11110_address_term = A
            & v7591(VarNext) )
         => ( ( v4933_35__array(VarNext,A,bitIndex43)
            <=> v7597(VarNext,bitIndex1363) )
            & ( v4933_35__array(VarNext,A,bitIndex42)
            <=> v7597(VarNext,bitIndex1362) )
            & ( v4933_35__array(VarNext,A,bitIndex41)
            <=> v7597(VarNext,bitIndex1361) )
            & ( v4933_35__array(VarNext,A,bitIndex40)
            <=> v7597(VarNext,bitIndex1360) )
            & ( v4933_35__array(VarNext,A,bitIndex39)
            <=> v7597(VarNext,bitIndex1359) )
            & ( v4933_35__array(VarNext,A,bitIndex38)
            <=> v7597(VarNext,bitIndex1358) )
            & ( v4933_35__array(VarNext,A,bitIndex37)
            <=> v7597(VarNext,bitIndex1357) )
            & ( v4933_35__array(VarNext,A,bitIndex36)
            <=> v7597(VarNext,bitIndex1356) )
            & ( v4933_35__array(VarNext,A,bitIndex35)
            <=> v7597(VarNext,bitIndex1355) )
            & ( v4933_35__array(VarNext,A,bitIndex34)
            <=> v7597(VarNext,bitIndex1354) )
            & ( v4933_35__array(VarNext,A,bitIndex33)
            <=> v7597(VarNext,bitIndex1353) )
            & ( v4933_35__array(VarNext,A,bitIndex32)
            <=> v7597(VarNext,bitIndex1352) )
            & ( v4933_35__array(VarNext,A,bitIndex31)
            <=> v7597(VarNext,bitIndex1351) )
            & ( v4933_35__array(VarNext,A,bitIndex30)
            <=> v7597(VarNext,bitIndex1350) )
            & ( v4933_35__array(VarNext,A,bitIndex29)
            <=> v7597(VarNext,bitIndex1349) )
            & ( v4933_35__array(VarNext,A,bitIndex28)
            <=> v7597(VarNext,bitIndex1348) )
            & ( v4933_35__array(VarNext,A,bitIndex27)
            <=> v7597(VarNext,bitIndex1347) )
            & ( v4933_35__array(VarNext,A,bitIndex26)
            <=> v7597(VarNext,bitIndex1346) )
            & ( v4933_35__array(VarNext,A,bitIndex25)
            <=> v7597(VarNext,bitIndex1345) )
            & ( v4933_35__array(VarNext,A,bitIndex24)
            <=> v7597(VarNext,bitIndex1344) )
            & ( v4933_35__array(VarNext,A,bitIndex23)
            <=> v7597(VarNext,bitIndex1343) )
            & ( v4933_35__array(VarNext,A,bitIndex22)
            <=> v7597(VarNext,bitIndex1342) )
            & ( v4933_35__array(VarNext,A,bitIndex21)
            <=> v7597(VarNext,bitIndex1341) )
            & ( v4933_35__array(VarNext,A,bitIndex20)
            <=> v7597(VarNext,bitIndex1340) )
            & ( v4933_35__array(VarNext,A,bitIndex19)
            <=> v7597(VarNext,bitIndex1339) )
            & ( v4933_35__array(VarNext,A,bitIndex18)
            <=> v7597(VarNext,bitIndex1338) )
            & ( v4933_35__array(VarNext,A,bitIndex17)
            <=> v7597(VarNext,bitIndex1337) )
            & ( v4933_35__array(VarNext,A,bitIndex16)
            <=> v7597(VarNext,bitIndex1336) )
            & ( v4933_35__array(VarNext,A,bitIndex15)
            <=> v7597(VarNext,bitIndex1335) )
            & ( v4933_35__array(VarNext,A,bitIndex14)
            <=> v7597(VarNext,bitIndex1334) )
            & ( v4933_35__array(VarNext,A,bitIndex13)
            <=> v7597(VarNext,bitIndex1333) )
            & ( v4933_35__array(VarNext,A,bitIndex12)
            <=> v7597(VarNext,bitIndex1332) )
            & ( v4933_35__array(VarNext,A,bitIndex11)
            <=> v7597(VarNext,bitIndex1331) )
            & ( v4933_35__array(VarNext,A,bitIndex10)
            <=> v7597(VarNext,bitIndex1330) )
            & ( v4933_35__array(VarNext,A,bitIndex9)
            <=> v7597(VarNext,bitIndex1329) )
            & ( v4933_35__array(VarNext,A,bitIndex8)
            <=> v7597(VarNext,bitIndex1328) )
            & ( v4933_35__array(VarNext,A,bitIndex7)
            <=> v7597(VarNext,bitIndex1327) )
            & ( v4933_35__array(VarNext,A,bitIndex6)
            <=> v7597(VarNext,bitIndex1326) )
            & ( v4933_35__array(VarNext,A,bitIndex5)
            <=> v7597(VarNext,bitIndex1325) )
            & ( v4933_35__array(VarNext,A,bitIndex4)
            <=> v7597(VarNext,bitIndex1324) )
            & ( v4933_35__array(VarNext,A,bitIndex3)
            <=> v7597(VarNext,bitIndex1323) )
            & ( v4933_35__array(VarNext,A,bitIndex2)
            <=> v7597(VarNext,bitIndex1322) )
            & ( v4933_35__array(VarNext,A,bitIndex1)
            <=> v7597(VarNext,bitIndex1321) )
            & ( v4933_35__array(VarNext,A,bitIndex0)
            <=> v7597(VarNext,bitIndex1320) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1369,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7591(VarNext)
      <=> ( v7592(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1368,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7592(VarNext)
      <=> ( v7594(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_645,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7594(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_53,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11101_address_term = A
              & v7582(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_34__array(VarNext,A,B)
              <=> v4933_33__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_53,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11101_address_term = A
            & v7582(VarNext) )
         => ( ( v4933_34__array(VarNext,A,bitIndex43)
            <=> v7588(VarNext,bitIndex1319) )
            & ( v4933_34__array(VarNext,A,bitIndex42)
            <=> v7588(VarNext,bitIndex1318) )
            & ( v4933_34__array(VarNext,A,bitIndex41)
            <=> v7588(VarNext,bitIndex1317) )
            & ( v4933_34__array(VarNext,A,bitIndex40)
            <=> v7588(VarNext,bitIndex1316) )
            & ( v4933_34__array(VarNext,A,bitIndex39)
            <=> v7588(VarNext,bitIndex1315) )
            & ( v4933_34__array(VarNext,A,bitIndex38)
            <=> v7588(VarNext,bitIndex1314) )
            & ( v4933_34__array(VarNext,A,bitIndex37)
            <=> v7588(VarNext,bitIndex1313) )
            & ( v4933_34__array(VarNext,A,bitIndex36)
            <=> v7588(VarNext,bitIndex1312) )
            & ( v4933_34__array(VarNext,A,bitIndex35)
            <=> v7588(VarNext,bitIndex1311) )
            & ( v4933_34__array(VarNext,A,bitIndex34)
            <=> v7588(VarNext,bitIndex1310) )
            & ( v4933_34__array(VarNext,A,bitIndex33)
            <=> v7588(VarNext,bitIndex1309) )
            & ( v4933_34__array(VarNext,A,bitIndex32)
            <=> v7588(VarNext,bitIndex1308) )
            & ( v4933_34__array(VarNext,A,bitIndex31)
            <=> v7588(VarNext,bitIndex1307) )
            & ( v4933_34__array(VarNext,A,bitIndex30)
            <=> v7588(VarNext,bitIndex1306) )
            & ( v4933_34__array(VarNext,A,bitIndex29)
            <=> v7588(VarNext,bitIndex1305) )
            & ( v4933_34__array(VarNext,A,bitIndex28)
            <=> v7588(VarNext,bitIndex1304) )
            & ( v4933_34__array(VarNext,A,bitIndex27)
            <=> v7588(VarNext,bitIndex1303) )
            & ( v4933_34__array(VarNext,A,bitIndex26)
            <=> v7588(VarNext,bitIndex1302) )
            & ( v4933_34__array(VarNext,A,bitIndex25)
            <=> v7588(VarNext,bitIndex1301) )
            & ( v4933_34__array(VarNext,A,bitIndex24)
            <=> v7588(VarNext,bitIndex1300) )
            & ( v4933_34__array(VarNext,A,bitIndex23)
            <=> v7588(VarNext,bitIndex1299) )
            & ( v4933_34__array(VarNext,A,bitIndex22)
            <=> v7588(VarNext,bitIndex1298) )
            & ( v4933_34__array(VarNext,A,bitIndex21)
            <=> v7588(VarNext,bitIndex1297) )
            & ( v4933_34__array(VarNext,A,bitIndex20)
            <=> v7588(VarNext,bitIndex1296) )
            & ( v4933_34__array(VarNext,A,bitIndex19)
            <=> v7588(VarNext,bitIndex1295) )
            & ( v4933_34__array(VarNext,A,bitIndex18)
            <=> v7588(VarNext,bitIndex1294) )
            & ( v4933_34__array(VarNext,A,bitIndex17)
            <=> v7588(VarNext,bitIndex1293) )
            & ( v4933_34__array(VarNext,A,bitIndex16)
            <=> v7588(VarNext,bitIndex1292) )
            & ( v4933_34__array(VarNext,A,bitIndex15)
            <=> v7588(VarNext,bitIndex1291) )
            & ( v4933_34__array(VarNext,A,bitIndex14)
            <=> v7588(VarNext,bitIndex1290) )
            & ( v4933_34__array(VarNext,A,bitIndex13)
            <=> v7588(VarNext,bitIndex1289) )
            & ( v4933_34__array(VarNext,A,bitIndex12)
            <=> v7588(VarNext,bitIndex1288) )
            & ( v4933_34__array(VarNext,A,bitIndex11)
            <=> v7588(VarNext,bitIndex1287) )
            & ( v4933_34__array(VarNext,A,bitIndex10)
            <=> v7588(VarNext,bitIndex1286) )
            & ( v4933_34__array(VarNext,A,bitIndex9)
            <=> v7588(VarNext,bitIndex1285) )
            & ( v4933_34__array(VarNext,A,bitIndex8)
            <=> v7588(VarNext,bitIndex1284) )
            & ( v4933_34__array(VarNext,A,bitIndex7)
            <=> v7588(VarNext,bitIndex1283) )
            & ( v4933_34__array(VarNext,A,bitIndex6)
            <=> v7588(VarNext,bitIndex1282) )
            & ( v4933_34__array(VarNext,A,bitIndex5)
            <=> v7588(VarNext,bitIndex1281) )
            & ( v4933_34__array(VarNext,A,bitIndex4)
            <=> v7588(VarNext,bitIndex1280) )
            & ( v4933_34__array(VarNext,A,bitIndex3)
            <=> v7588(VarNext,bitIndex1279) )
            & ( v4933_34__array(VarNext,A,bitIndex2)
            <=> v7588(VarNext,bitIndex1278) )
            & ( v4933_34__array(VarNext,A,bitIndex1)
            <=> v7588(VarNext,bitIndex1277) )
            & ( v4933_34__array(VarNext,A,bitIndex0)
            <=> v7588(VarNext,bitIndex1276) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1367,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7582(VarNext)
      <=> ( v7583(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1366,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7583(VarNext)
      <=> ( v7585(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_644,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7585(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_52,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11100_address_term = A
              & v7573(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_33__array(VarNext,A,B)
              <=> v4933_32__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_52,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11100_address_term = A
            & v7573(VarNext) )
         => ( ( v4933_33__array(VarNext,A,bitIndex43)
            <=> v7579(VarNext,bitIndex1275) )
            & ( v4933_33__array(VarNext,A,bitIndex42)
            <=> v7579(VarNext,bitIndex1274) )
            & ( v4933_33__array(VarNext,A,bitIndex41)
            <=> v7579(VarNext,bitIndex1273) )
            & ( v4933_33__array(VarNext,A,bitIndex40)
            <=> v7579(VarNext,bitIndex1272) )
            & ( v4933_33__array(VarNext,A,bitIndex39)
            <=> v7579(VarNext,bitIndex1271) )
            & ( v4933_33__array(VarNext,A,bitIndex38)
            <=> v7579(VarNext,bitIndex1270) )
            & ( v4933_33__array(VarNext,A,bitIndex37)
            <=> v7579(VarNext,bitIndex1269) )
            & ( v4933_33__array(VarNext,A,bitIndex36)
            <=> v7579(VarNext,bitIndex1268) )
            & ( v4933_33__array(VarNext,A,bitIndex35)
            <=> v7579(VarNext,bitIndex1267) )
            & ( v4933_33__array(VarNext,A,bitIndex34)
            <=> v7579(VarNext,bitIndex1266) )
            & ( v4933_33__array(VarNext,A,bitIndex33)
            <=> v7579(VarNext,bitIndex1265) )
            & ( v4933_33__array(VarNext,A,bitIndex32)
            <=> v7579(VarNext,bitIndex1264) )
            & ( v4933_33__array(VarNext,A,bitIndex31)
            <=> v7579(VarNext,bitIndex1263) )
            & ( v4933_33__array(VarNext,A,bitIndex30)
            <=> v7579(VarNext,bitIndex1262) )
            & ( v4933_33__array(VarNext,A,bitIndex29)
            <=> v7579(VarNext,bitIndex1261) )
            & ( v4933_33__array(VarNext,A,bitIndex28)
            <=> v7579(VarNext,bitIndex1260) )
            & ( v4933_33__array(VarNext,A,bitIndex27)
            <=> v7579(VarNext,bitIndex1259) )
            & ( v4933_33__array(VarNext,A,bitIndex26)
            <=> v7579(VarNext,bitIndex1258) )
            & ( v4933_33__array(VarNext,A,bitIndex25)
            <=> v7579(VarNext,bitIndex1257) )
            & ( v4933_33__array(VarNext,A,bitIndex24)
            <=> v7579(VarNext,bitIndex1256) )
            & ( v4933_33__array(VarNext,A,bitIndex23)
            <=> v7579(VarNext,bitIndex1255) )
            & ( v4933_33__array(VarNext,A,bitIndex22)
            <=> v7579(VarNext,bitIndex1254) )
            & ( v4933_33__array(VarNext,A,bitIndex21)
            <=> v7579(VarNext,bitIndex1253) )
            & ( v4933_33__array(VarNext,A,bitIndex20)
            <=> v7579(VarNext,bitIndex1252) )
            & ( v4933_33__array(VarNext,A,bitIndex19)
            <=> v7579(VarNext,bitIndex1251) )
            & ( v4933_33__array(VarNext,A,bitIndex18)
            <=> v7579(VarNext,bitIndex1250) )
            & ( v4933_33__array(VarNext,A,bitIndex17)
            <=> v7579(VarNext,bitIndex1249) )
            & ( v4933_33__array(VarNext,A,bitIndex16)
            <=> v7579(VarNext,bitIndex1248) )
            & ( v4933_33__array(VarNext,A,bitIndex15)
            <=> v7579(VarNext,bitIndex1247) )
            & ( v4933_33__array(VarNext,A,bitIndex14)
            <=> v7579(VarNext,bitIndex1246) )
            & ( v4933_33__array(VarNext,A,bitIndex13)
            <=> v7579(VarNext,bitIndex1245) )
            & ( v4933_33__array(VarNext,A,bitIndex12)
            <=> v7579(VarNext,bitIndex1244) )
            & ( v4933_33__array(VarNext,A,bitIndex11)
            <=> v7579(VarNext,bitIndex1243) )
            & ( v4933_33__array(VarNext,A,bitIndex10)
            <=> v7579(VarNext,bitIndex1242) )
            & ( v4933_33__array(VarNext,A,bitIndex9)
            <=> v7579(VarNext,bitIndex1241) )
            & ( v4933_33__array(VarNext,A,bitIndex8)
            <=> v7579(VarNext,bitIndex1240) )
            & ( v4933_33__array(VarNext,A,bitIndex7)
            <=> v7579(VarNext,bitIndex1239) )
            & ( v4933_33__array(VarNext,A,bitIndex6)
            <=> v7579(VarNext,bitIndex1238) )
            & ( v4933_33__array(VarNext,A,bitIndex5)
            <=> v7579(VarNext,bitIndex1237) )
            & ( v4933_33__array(VarNext,A,bitIndex4)
            <=> v7579(VarNext,bitIndex1236) )
            & ( v4933_33__array(VarNext,A,bitIndex3)
            <=> v7579(VarNext,bitIndex1235) )
            & ( v4933_33__array(VarNext,A,bitIndex2)
            <=> v7579(VarNext,bitIndex1234) )
            & ( v4933_33__array(VarNext,A,bitIndex1)
            <=> v7579(VarNext,bitIndex1233) )
            & ( v4933_33__array(VarNext,A,bitIndex0)
            <=> v7579(VarNext,bitIndex1232) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1365,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7573(VarNext)
      <=> ( v7574(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1364,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7574(VarNext)
      <=> ( v7576(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_643,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7576(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_51,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11011_address_term = A
              & v7564(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_32__array(VarNext,A,B)
              <=> v4933_31__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_51,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11011_address_term = A
            & v7564(VarNext) )
         => ( ( v4933_32__array(VarNext,A,bitIndex43)
            <=> v7570(VarNext,bitIndex1231) )
            & ( v4933_32__array(VarNext,A,bitIndex42)
            <=> v7570(VarNext,bitIndex1230) )
            & ( v4933_32__array(VarNext,A,bitIndex41)
            <=> v7570(VarNext,bitIndex1229) )
            & ( v4933_32__array(VarNext,A,bitIndex40)
            <=> v7570(VarNext,bitIndex1228) )
            & ( v4933_32__array(VarNext,A,bitIndex39)
            <=> v7570(VarNext,bitIndex1227) )
            & ( v4933_32__array(VarNext,A,bitIndex38)
            <=> v7570(VarNext,bitIndex1226) )
            & ( v4933_32__array(VarNext,A,bitIndex37)
            <=> v7570(VarNext,bitIndex1225) )
            & ( v4933_32__array(VarNext,A,bitIndex36)
            <=> v7570(VarNext,bitIndex1224) )
            & ( v4933_32__array(VarNext,A,bitIndex35)
            <=> v7570(VarNext,bitIndex1223) )
            & ( v4933_32__array(VarNext,A,bitIndex34)
            <=> v7570(VarNext,bitIndex1222) )
            & ( v4933_32__array(VarNext,A,bitIndex33)
            <=> v7570(VarNext,bitIndex1221) )
            & ( v4933_32__array(VarNext,A,bitIndex32)
            <=> v7570(VarNext,bitIndex1220) )
            & ( v4933_32__array(VarNext,A,bitIndex31)
            <=> v7570(VarNext,bitIndex1219) )
            & ( v4933_32__array(VarNext,A,bitIndex30)
            <=> v7570(VarNext,bitIndex1218) )
            & ( v4933_32__array(VarNext,A,bitIndex29)
            <=> v7570(VarNext,bitIndex1217) )
            & ( v4933_32__array(VarNext,A,bitIndex28)
            <=> v7570(VarNext,bitIndex1216) )
            & ( v4933_32__array(VarNext,A,bitIndex27)
            <=> v7570(VarNext,bitIndex1215) )
            & ( v4933_32__array(VarNext,A,bitIndex26)
            <=> v7570(VarNext,bitIndex1214) )
            & ( v4933_32__array(VarNext,A,bitIndex25)
            <=> v7570(VarNext,bitIndex1213) )
            & ( v4933_32__array(VarNext,A,bitIndex24)
            <=> v7570(VarNext,bitIndex1212) )
            & ( v4933_32__array(VarNext,A,bitIndex23)
            <=> v7570(VarNext,bitIndex1211) )
            & ( v4933_32__array(VarNext,A,bitIndex22)
            <=> v7570(VarNext,bitIndex1210) )
            & ( v4933_32__array(VarNext,A,bitIndex21)
            <=> v7570(VarNext,bitIndex1209) )
            & ( v4933_32__array(VarNext,A,bitIndex20)
            <=> v7570(VarNext,bitIndex1208) )
            & ( v4933_32__array(VarNext,A,bitIndex19)
            <=> v7570(VarNext,bitIndex1207) )
            & ( v4933_32__array(VarNext,A,bitIndex18)
            <=> v7570(VarNext,bitIndex1206) )
            & ( v4933_32__array(VarNext,A,bitIndex17)
            <=> v7570(VarNext,bitIndex1205) )
            & ( v4933_32__array(VarNext,A,bitIndex16)
            <=> v7570(VarNext,bitIndex1204) )
            & ( v4933_32__array(VarNext,A,bitIndex15)
            <=> v7570(VarNext,bitIndex1203) )
            & ( v4933_32__array(VarNext,A,bitIndex14)
            <=> v7570(VarNext,bitIndex1202) )
            & ( v4933_32__array(VarNext,A,bitIndex13)
            <=> v7570(VarNext,bitIndex1201) )
            & ( v4933_32__array(VarNext,A,bitIndex12)
            <=> v7570(VarNext,bitIndex1200) )
            & ( v4933_32__array(VarNext,A,bitIndex11)
            <=> v7570(VarNext,bitIndex1199) )
            & ( v4933_32__array(VarNext,A,bitIndex10)
            <=> v7570(VarNext,bitIndex1198) )
            & ( v4933_32__array(VarNext,A,bitIndex9)
            <=> v7570(VarNext,bitIndex1197) )
            & ( v4933_32__array(VarNext,A,bitIndex8)
            <=> v7570(VarNext,bitIndex1196) )
            & ( v4933_32__array(VarNext,A,bitIndex7)
            <=> v7570(VarNext,bitIndex1195) )
            & ( v4933_32__array(VarNext,A,bitIndex6)
            <=> v7570(VarNext,bitIndex1194) )
            & ( v4933_32__array(VarNext,A,bitIndex5)
            <=> v7570(VarNext,bitIndex1193) )
            & ( v4933_32__array(VarNext,A,bitIndex4)
            <=> v7570(VarNext,bitIndex1192) )
            & ( v4933_32__array(VarNext,A,bitIndex3)
            <=> v7570(VarNext,bitIndex1191) )
            & ( v4933_32__array(VarNext,A,bitIndex2)
            <=> v7570(VarNext,bitIndex1190) )
            & ( v4933_32__array(VarNext,A,bitIndex1)
            <=> v7570(VarNext,bitIndex1189) )
            & ( v4933_32__array(VarNext,A,bitIndex0)
            <=> v7570(VarNext,bitIndex1188) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1363,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7564(VarNext)
      <=> ( v7565(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1362,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7565(VarNext)
      <=> ( v7567(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_642,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7567(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_50,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11010_address_term = A
              & v7555(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_31__array(VarNext,A,B)
              <=> v4933_30__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_50,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11010_address_term = A
            & v7555(VarNext) )
         => ( ( v4933_31__array(VarNext,A,bitIndex43)
            <=> v7561(VarNext,bitIndex1187) )
            & ( v4933_31__array(VarNext,A,bitIndex42)
            <=> v7561(VarNext,bitIndex1186) )
            & ( v4933_31__array(VarNext,A,bitIndex41)
            <=> v7561(VarNext,bitIndex1185) )
            & ( v4933_31__array(VarNext,A,bitIndex40)
            <=> v7561(VarNext,bitIndex1184) )
            & ( v4933_31__array(VarNext,A,bitIndex39)
            <=> v7561(VarNext,bitIndex1183) )
            & ( v4933_31__array(VarNext,A,bitIndex38)
            <=> v7561(VarNext,bitIndex1182) )
            & ( v4933_31__array(VarNext,A,bitIndex37)
            <=> v7561(VarNext,bitIndex1181) )
            & ( v4933_31__array(VarNext,A,bitIndex36)
            <=> v7561(VarNext,bitIndex1180) )
            & ( v4933_31__array(VarNext,A,bitIndex35)
            <=> v7561(VarNext,bitIndex1179) )
            & ( v4933_31__array(VarNext,A,bitIndex34)
            <=> v7561(VarNext,bitIndex1178) )
            & ( v4933_31__array(VarNext,A,bitIndex33)
            <=> v7561(VarNext,bitIndex1177) )
            & ( v4933_31__array(VarNext,A,bitIndex32)
            <=> v7561(VarNext,bitIndex1176) )
            & ( v4933_31__array(VarNext,A,bitIndex31)
            <=> v7561(VarNext,bitIndex1175) )
            & ( v4933_31__array(VarNext,A,bitIndex30)
            <=> v7561(VarNext,bitIndex1174) )
            & ( v4933_31__array(VarNext,A,bitIndex29)
            <=> v7561(VarNext,bitIndex1173) )
            & ( v4933_31__array(VarNext,A,bitIndex28)
            <=> v7561(VarNext,bitIndex1172) )
            & ( v4933_31__array(VarNext,A,bitIndex27)
            <=> v7561(VarNext,bitIndex1171) )
            & ( v4933_31__array(VarNext,A,bitIndex26)
            <=> v7561(VarNext,bitIndex1170) )
            & ( v4933_31__array(VarNext,A,bitIndex25)
            <=> v7561(VarNext,bitIndex1169) )
            & ( v4933_31__array(VarNext,A,bitIndex24)
            <=> v7561(VarNext,bitIndex1168) )
            & ( v4933_31__array(VarNext,A,bitIndex23)
            <=> v7561(VarNext,bitIndex1167) )
            & ( v4933_31__array(VarNext,A,bitIndex22)
            <=> v7561(VarNext,bitIndex1166) )
            & ( v4933_31__array(VarNext,A,bitIndex21)
            <=> v7561(VarNext,bitIndex1165) )
            & ( v4933_31__array(VarNext,A,bitIndex20)
            <=> v7561(VarNext,bitIndex1164) )
            & ( v4933_31__array(VarNext,A,bitIndex19)
            <=> v7561(VarNext,bitIndex1163) )
            & ( v4933_31__array(VarNext,A,bitIndex18)
            <=> v7561(VarNext,bitIndex1162) )
            & ( v4933_31__array(VarNext,A,bitIndex17)
            <=> v7561(VarNext,bitIndex1161) )
            & ( v4933_31__array(VarNext,A,bitIndex16)
            <=> v7561(VarNext,bitIndex1160) )
            & ( v4933_31__array(VarNext,A,bitIndex15)
            <=> v7561(VarNext,bitIndex1159) )
            & ( v4933_31__array(VarNext,A,bitIndex14)
            <=> v7561(VarNext,bitIndex1158) )
            & ( v4933_31__array(VarNext,A,bitIndex13)
            <=> v7561(VarNext,bitIndex1157) )
            & ( v4933_31__array(VarNext,A,bitIndex12)
            <=> v7561(VarNext,bitIndex1156) )
            & ( v4933_31__array(VarNext,A,bitIndex11)
            <=> v7561(VarNext,bitIndex1155) )
            & ( v4933_31__array(VarNext,A,bitIndex10)
            <=> v7561(VarNext,bitIndex1154) )
            & ( v4933_31__array(VarNext,A,bitIndex9)
            <=> v7561(VarNext,bitIndex1153) )
            & ( v4933_31__array(VarNext,A,bitIndex8)
            <=> v7561(VarNext,bitIndex1152) )
            & ( v4933_31__array(VarNext,A,bitIndex7)
            <=> v7561(VarNext,bitIndex1151) )
            & ( v4933_31__array(VarNext,A,bitIndex6)
            <=> v7561(VarNext,bitIndex1150) )
            & ( v4933_31__array(VarNext,A,bitIndex5)
            <=> v7561(VarNext,bitIndex1149) )
            & ( v4933_31__array(VarNext,A,bitIndex4)
            <=> v7561(VarNext,bitIndex1148) )
            & ( v4933_31__array(VarNext,A,bitIndex3)
            <=> v7561(VarNext,bitIndex1147) )
            & ( v4933_31__array(VarNext,A,bitIndex2)
            <=> v7561(VarNext,bitIndex1146) )
            & ( v4933_31__array(VarNext,A,bitIndex1)
            <=> v7561(VarNext,bitIndex1145) )
            & ( v4933_31__array(VarNext,A,bitIndex0)
            <=> v7561(VarNext,bitIndex1144) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1361,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7555(VarNext)
      <=> ( v7556(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1360,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7556(VarNext)
      <=> ( v7558(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_641,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7558(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_49,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11001_address_term = A
              & v7546(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_30__array(VarNext,A,B)
              <=> v4933_29__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_49,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11001_address_term = A
            & v7546(VarNext) )
         => ( ( v4933_30__array(VarNext,A,bitIndex43)
            <=> v7552(VarNext,bitIndex1143) )
            & ( v4933_30__array(VarNext,A,bitIndex42)
            <=> v7552(VarNext,bitIndex1142) )
            & ( v4933_30__array(VarNext,A,bitIndex41)
            <=> v7552(VarNext,bitIndex1141) )
            & ( v4933_30__array(VarNext,A,bitIndex40)
            <=> v7552(VarNext,bitIndex1140) )
            & ( v4933_30__array(VarNext,A,bitIndex39)
            <=> v7552(VarNext,bitIndex1139) )
            & ( v4933_30__array(VarNext,A,bitIndex38)
            <=> v7552(VarNext,bitIndex1138) )
            & ( v4933_30__array(VarNext,A,bitIndex37)
            <=> v7552(VarNext,bitIndex1137) )
            & ( v4933_30__array(VarNext,A,bitIndex36)
            <=> v7552(VarNext,bitIndex1136) )
            & ( v4933_30__array(VarNext,A,bitIndex35)
            <=> v7552(VarNext,bitIndex1135) )
            & ( v4933_30__array(VarNext,A,bitIndex34)
            <=> v7552(VarNext,bitIndex1134) )
            & ( v4933_30__array(VarNext,A,bitIndex33)
            <=> v7552(VarNext,bitIndex1133) )
            & ( v4933_30__array(VarNext,A,bitIndex32)
            <=> v7552(VarNext,bitIndex1132) )
            & ( v4933_30__array(VarNext,A,bitIndex31)
            <=> v7552(VarNext,bitIndex1131) )
            & ( v4933_30__array(VarNext,A,bitIndex30)
            <=> v7552(VarNext,bitIndex1130) )
            & ( v4933_30__array(VarNext,A,bitIndex29)
            <=> v7552(VarNext,bitIndex1129) )
            & ( v4933_30__array(VarNext,A,bitIndex28)
            <=> v7552(VarNext,bitIndex1128) )
            & ( v4933_30__array(VarNext,A,bitIndex27)
            <=> v7552(VarNext,bitIndex1127) )
            & ( v4933_30__array(VarNext,A,bitIndex26)
            <=> v7552(VarNext,bitIndex1126) )
            & ( v4933_30__array(VarNext,A,bitIndex25)
            <=> v7552(VarNext,bitIndex1125) )
            & ( v4933_30__array(VarNext,A,bitIndex24)
            <=> v7552(VarNext,bitIndex1124) )
            & ( v4933_30__array(VarNext,A,bitIndex23)
            <=> v7552(VarNext,bitIndex1123) )
            & ( v4933_30__array(VarNext,A,bitIndex22)
            <=> v7552(VarNext,bitIndex1122) )
            & ( v4933_30__array(VarNext,A,bitIndex21)
            <=> v7552(VarNext,bitIndex1121) )
            & ( v4933_30__array(VarNext,A,bitIndex20)
            <=> v7552(VarNext,bitIndex1120) )
            & ( v4933_30__array(VarNext,A,bitIndex19)
            <=> v7552(VarNext,bitIndex1119) )
            & ( v4933_30__array(VarNext,A,bitIndex18)
            <=> v7552(VarNext,bitIndex1118) )
            & ( v4933_30__array(VarNext,A,bitIndex17)
            <=> v7552(VarNext,bitIndex1117) )
            & ( v4933_30__array(VarNext,A,bitIndex16)
            <=> v7552(VarNext,bitIndex1116) )
            & ( v4933_30__array(VarNext,A,bitIndex15)
            <=> v7552(VarNext,bitIndex1115) )
            & ( v4933_30__array(VarNext,A,bitIndex14)
            <=> v7552(VarNext,bitIndex1114) )
            & ( v4933_30__array(VarNext,A,bitIndex13)
            <=> v7552(VarNext,bitIndex1113) )
            & ( v4933_30__array(VarNext,A,bitIndex12)
            <=> v7552(VarNext,bitIndex1112) )
            & ( v4933_30__array(VarNext,A,bitIndex11)
            <=> v7552(VarNext,bitIndex1111) )
            & ( v4933_30__array(VarNext,A,bitIndex10)
            <=> v7552(VarNext,bitIndex1110) )
            & ( v4933_30__array(VarNext,A,bitIndex9)
            <=> v7552(VarNext,bitIndex1109) )
            & ( v4933_30__array(VarNext,A,bitIndex8)
            <=> v7552(VarNext,bitIndex1108) )
            & ( v4933_30__array(VarNext,A,bitIndex7)
            <=> v7552(VarNext,bitIndex1107) )
            & ( v4933_30__array(VarNext,A,bitIndex6)
            <=> v7552(VarNext,bitIndex1106) )
            & ( v4933_30__array(VarNext,A,bitIndex5)
            <=> v7552(VarNext,bitIndex1105) )
            & ( v4933_30__array(VarNext,A,bitIndex4)
            <=> v7552(VarNext,bitIndex1104) )
            & ( v4933_30__array(VarNext,A,bitIndex3)
            <=> v7552(VarNext,bitIndex1103) )
            & ( v4933_30__array(VarNext,A,bitIndex2)
            <=> v7552(VarNext,bitIndex1102) )
            & ( v4933_30__array(VarNext,A,bitIndex1)
            <=> v7552(VarNext,bitIndex1101) )
            & ( v4933_30__array(VarNext,A,bitIndex0)
            <=> v7552(VarNext,bitIndex1100) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1359,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7546(VarNext)
      <=> ( v7547(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1358,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7547(VarNext)
      <=> ( v7549(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_640,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7549(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_48,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b11000_address_term = A
              & v7537(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_29__array(VarNext,A,B)
              <=> v4933_28__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_48,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b11000_address_term = A
            & v7537(VarNext) )
         => ( ( v4933_29__array(VarNext,A,bitIndex43)
            <=> v7543(VarNext,bitIndex1099) )
            & ( v4933_29__array(VarNext,A,bitIndex42)
            <=> v7543(VarNext,bitIndex1098) )
            & ( v4933_29__array(VarNext,A,bitIndex41)
            <=> v7543(VarNext,bitIndex1097) )
            & ( v4933_29__array(VarNext,A,bitIndex40)
            <=> v7543(VarNext,bitIndex1096) )
            & ( v4933_29__array(VarNext,A,bitIndex39)
            <=> v7543(VarNext,bitIndex1095) )
            & ( v4933_29__array(VarNext,A,bitIndex38)
            <=> v7543(VarNext,bitIndex1094) )
            & ( v4933_29__array(VarNext,A,bitIndex37)
            <=> v7543(VarNext,bitIndex1093) )
            & ( v4933_29__array(VarNext,A,bitIndex36)
            <=> v7543(VarNext,bitIndex1092) )
            & ( v4933_29__array(VarNext,A,bitIndex35)
            <=> v7543(VarNext,bitIndex1091) )
            & ( v4933_29__array(VarNext,A,bitIndex34)
            <=> v7543(VarNext,bitIndex1090) )
            & ( v4933_29__array(VarNext,A,bitIndex33)
            <=> v7543(VarNext,bitIndex1089) )
            & ( v4933_29__array(VarNext,A,bitIndex32)
            <=> v7543(VarNext,bitIndex1088) )
            & ( v4933_29__array(VarNext,A,bitIndex31)
            <=> v7543(VarNext,bitIndex1087) )
            & ( v4933_29__array(VarNext,A,bitIndex30)
            <=> v7543(VarNext,bitIndex1086) )
            & ( v4933_29__array(VarNext,A,bitIndex29)
            <=> v7543(VarNext,bitIndex1085) )
            & ( v4933_29__array(VarNext,A,bitIndex28)
            <=> v7543(VarNext,bitIndex1084) )
            & ( v4933_29__array(VarNext,A,bitIndex27)
            <=> v7543(VarNext,bitIndex1083) )
            & ( v4933_29__array(VarNext,A,bitIndex26)
            <=> v7543(VarNext,bitIndex1082) )
            & ( v4933_29__array(VarNext,A,bitIndex25)
            <=> v7543(VarNext,bitIndex1081) )
            & ( v4933_29__array(VarNext,A,bitIndex24)
            <=> v7543(VarNext,bitIndex1080) )
            & ( v4933_29__array(VarNext,A,bitIndex23)
            <=> v7543(VarNext,bitIndex1079) )
            & ( v4933_29__array(VarNext,A,bitIndex22)
            <=> v7543(VarNext,bitIndex1078) )
            & ( v4933_29__array(VarNext,A,bitIndex21)
            <=> v7543(VarNext,bitIndex1077) )
            & ( v4933_29__array(VarNext,A,bitIndex20)
            <=> v7543(VarNext,bitIndex1076) )
            & ( v4933_29__array(VarNext,A,bitIndex19)
            <=> v7543(VarNext,bitIndex1075) )
            & ( v4933_29__array(VarNext,A,bitIndex18)
            <=> v7543(VarNext,bitIndex1074) )
            & ( v4933_29__array(VarNext,A,bitIndex17)
            <=> v7543(VarNext,bitIndex1073) )
            & ( v4933_29__array(VarNext,A,bitIndex16)
            <=> v7543(VarNext,bitIndex1072) )
            & ( v4933_29__array(VarNext,A,bitIndex15)
            <=> v7543(VarNext,bitIndex1071) )
            & ( v4933_29__array(VarNext,A,bitIndex14)
            <=> v7543(VarNext,bitIndex1070) )
            & ( v4933_29__array(VarNext,A,bitIndex13)
            <=> v7543(VarNext,bitIndex1069) )
            & ( v4933_29__array(VarNext,A,bitIndex12)
            <=> v7543(VarNext,bitIndex1068) )
            & ( v4933_29__array(VarNext,A,bitIndex11)
            <=> v7543(VarNext,bitIndex1067) )
            & ( v4933_29__array(VarNext,A,bitIndex10)
            <=> v7543(VarNext,bitIndex1066) )
            & ( v4933_29__array(VarNext,A,bitIndex9)
            <=> v7543(VarNext,bitIndex1065) )
            & ( v4933_29__array(VarNext,A,bitIndex8)
            <=> v7543(VarNext,bitIndex1064) )
            & ( v4933_29__array(VarNext,A,bitIndex7)
            <=> v7543(VarNext,bitIndex1063) )
            & ( v4933_29__array(VarNext,A,bitIndex6)
            <=> v7543(VarNext,bitIndex1062) )
            & ( v4933_29__array(VarNext,A,bitIndex5)
            <=> v7543(VarNext,bitIndex1061) )
            & ( v4933_29__array(VarNext,A,bitIndex4)
            <=> v7543(VarNext,bitIndex1060) )
            & ( v4933_29__array(VarNext,A,bitIndex3)
            <=> v7543(VarNext,bitIndex1059) )
            & ( v4933_29__array(VarNext,A,bitIndex2)
            <=> v7543(VarNext,bitIndex1058) )
            & ( v4933_29__array(VarNext,A,bitIndex1)
            <=> v7543(VarNext,bitIndex1057) )
            & ( v4933_29__array(VarNext,A,bitIndex0)
            <=> v7543(VarNext,bitIndex1056) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1357,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7537(VarNext)
      <=> ( v7538(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1356,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7538(VarNext)
      <=> ( v7540(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_639,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7540(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_47,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10111_address_term = A
              & v7528(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_28__array(VarNext,A,B)
              <=> v4933_27__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_47,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10111_address_term = A
            & v7528(VarNext) )
         => ( ( v4933_28__array(VarNext,A,bitIndex43)
            <=> v7534(VarNext,bitIndex1055) )
            & ( v4933_28__array(VarNext,A,bitIndex42)
            <=> v7534(VarNext,bitIndex1054) )
            & ( v4933_28__array(VarNext,A,bitIndex41)
            <=> v7534(VarNext,bitIndex1053) )
            & ( v4933_28__array(VarNext,A,bitIndex40)
            <=> v7534(VarNext,bitIndex1052) )
            & ( v4933_28__array(VarNext,A,bitIndex39)
            <=> v7534(VarNext,bitIndex1051) )
            & ( v4933_28__array(VarNext,A,bitIndex38)
            <=> v7534(VarNext,bitIndex1050) )
            & ( v4933_28__array(VarNext,A,bitIndex37)
            <=> v7534(VarNext,bitIndex1049) )
            & ( v4933_28__array(VarNext,A,bitIndex36)
            <=> v7534(VarNext,bitIndex1048) )
            & ( v4933_28__array(VarNext,A,bitIndex35)
            <=> v7534(VarNext,bitIndex1047) )
            & ( v4933_28__array(VarNext,A,bitIndex34)
            <=> v7534(VarNext,bitIndex1046) )
            & ( v4933_28__array(VarNext,A,bitIndex33)
            <=> v7534(VarNext,bitIndex1045) )
            & ( v4933_28__array(VarNext,A,bitIndex32)
            <=> v7534(VarNext,bitIndex1044) )
            & ( v4933_28__array(VarNext,A,bitIndex31)
            <=> v7534(VarNext,bitIndex1043) )
            & ( v4933_28__array(VarNext,A,bitIndex30)
            <=> v7534(VarNext,bitIndex1042) )
            & ( v4933_28__array(VarNext,A,bitIndex29)
            <=> v7534(VarNext,bitIndex1041) )
            & ( v4933_28__array(VarNext,A,bitIndex28)
            <=> v7534(VarNext,bitIndex1040) )
            & ( v4933_28__array(VarNext,A,bitIndex27)
            <=> v7534(VarNext,bitIndex1039) )
            & ( v4933_28__array(VarNext,A,bitIndex26)
            <=> v7534(VarNext,bitIndex1038) )
            & ( v4933_28__array(VarNext,A,bitIndex25)
            <=> v7534(VarNext,bitIndex1037) )
            & ( v4933_28__array(VarNext,A,bitIndex24)
            <=> v7534(VarNext,bitIndex1036) )
            & ( v4933_28__array(VarNext,A,bitIndex23)
            <=> v7534(VarNext,bitIndex1035) )
            & ( v4933_28__array(VarNext,A,bitIndex22)
            <=> v7534(VarNext,bitIndex1034) )
            & ( v4933_28__array(VarNext,A,bitIndex21)
            <=> v7534(VarNext,bitIndex1033) )
            & ( v4933_28__array(VarNext,A,bitIndex20)
            <=> v7534(VarNext,bitIndex1032) )
            & ( v4933_28__array(VarNext,A,bitIndex19)
            <=> v7534(VarNext,bitIndex1031) )
            & ( v4933_28__array(VarNext,A,bitIndex18)
            <=> v7534(VarNext,bitIndex1030) )
            & ( v4933_28__array(VarNext,A,bitIndex17)
            <=> v7534(VarNext,bitIndex1029) )
            & ( v4933_28__array(VarNext,A,bitIndex16)
            <=> v7534(VarNext,bitIndex1028) )
            & ( v4933_28__array(VarNext,A,bitIndex15)
            <=> v7534(VarNext,bitIndex1027) )
            & ( v4933_28__array(VarNext,A,bitIndex14)
            <=> v7534(VarNext,bitIndex1026) )
            & ( v4933_28__array(VarNext,A,bitIndex13)
            <=> v7534(VarNext,bitIndex1025) )
            & ( v4933_28__array(VarNext,A,bitIndex12)
            <=> v7534(VarNext,bitIndex1024) )
            & ( v4933_28__array(VarNext,A,bitIndex11)
            <=> v7534(VarNext,bitIndex1023) )
            & ( v4933_28__array(VarNext,A,bitIndex10)
            <=> v7534(VarNext,bitIndex1022) )
            & ( v4933_28__array(VarNext,A,bitIndex9)
            <=> v7534(VarNext,bitIndex1021) )
            & ( v4933_28__array(VarNext,A,bitIndex8)
            <=> v7534(VarNext,bitIndex1020) )
            & ( v4933_28__array(VarNext,A,bitIndex7)
            <=> v7534(VarNext,bitIndex1019) )
            & ( v4933_28__array(VarNext,A,bitIndex6)
            <=> v7534(VarNext,bitIndex1018) )
            & ( v4933_28__array(VarNext,A,bitIndex5)
            <=> v7534(VarNext,bitIndex1017) )
            & ( v4933_28__array(VarNext,A,bitIndex4)
            <=> v7534(VarNext,bitIndex1016) )
            & ( v4933_28__array(VarNext,A,bitIndex3)
            <=> v7534(VarNext,bitIndex1015) )
            & ( v4933_28__array(VarNext,A,bitIndex2)
            <=> v7534(VarNext,bitIndex1014) )
            & ( v4933_28__array(VarNext,A,bitIndex1)
            <=> v7534(VarNext,bitIndex1013) )
            & ( v4933_28__array(VarNext,A,bitIndex0)
            <=> v7534(VarNext,bitIndex1012) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1355,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7528(VarNext)
      <=> ( v7529(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1354,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7529(VarNext)
      <=> ( v7531(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_638,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7531(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_46,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10110_address_term = A
              & v7519(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_27__array(VarNext,A,B)
              <=> v4933_26__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_46,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10110_address_term = A
            & v7519(VarNext) )
         => ( ( v4933_27__array(VarNext,A,bitIndex43)
            <=> v7525(VarNext,bitIndex1011) )
            & ( v4933_27__array(VarNext,A,bitIndex42)
            <=> v7525(VarNext,bitIndex1010) )
            & ( v4933_27__array(VarNext,A,bitIndex41)
            <=> v7525(VarNext,bitIndex1009) )
            & ( v4933_27__array(VarNext,A,bitIndex40)
            <=> v7525(VarNext,bitIndex1008) )
            & ( v4933_27__array(VarNext,A,bitIndex39)
            <=> v7525(VarNext,bitIndex1007) )
            & ( v4933_27__array(VarNext,A,bitIndex38)
            <=> v7525(VarNext,bitIndex1006) )
            & ( v4933_27__array(VarNext,A,bitIndex37)
            <=> v7525(VarNext,bitIndex1005) )
            & ( v4933_27__array(VarNext,A,bitIndex36)
            <=> v7525(VarNext,bitIndex1004) )
            & ( v4933_27__array(VarNext,A,bitIndex35)
            <=> v7525(VarNext,bitIndex1003) )
            & ( v4933_27__array(VarNext,A,bitIndex34)
            <=> v7525(VarNext,bitIndex1002) )
            & ( v4933_27__array(VarNext,A,bitIndex33)
            <=> v7525(VarNext,bitIndex1001) )
            & ( v4933_27__array(VarNext,A,bitIndex32)
            <=> v7525(VarNext,bitIndex1000) )
            & ( v4933_27__array(VarNext,A,bitIndex31)
            <=> v7525(VarNext,bitIndex999) )
            & ( v4933_27__array(VarNext,A,bitIndex30)
            <=> v7525(VarNext,bitIndex998) )
            & ( v4933_27__array(VarNext,A,bitIndex29)
            <=> v7525(VarNext,bitIndex997) )
            & ( v4933_27__array(VarNext,A,bitIndex28)
            <=> v7525(VarNext,bitIndex996) )
            & ( v4933_27__array(VarNext,A,bitIndex27)
            <=> v7525(VarNext,bitIndex995) )
            & ( v4933_27__array(VarNext,A,bitIndex26)
            <=> v7525(VarNext,bitIndex994) )
            & ( v4933_27__array(VarNext,A,bitIndex25)
            <=> v7525(VarNext,bitIndex993) )
            & ( v4933_27__array(VarNext,A,bitIndex24)
            <=> v7525(VarNext,bitIndex992) )
            & ( v4933_27__array(VarNext,A,bitIndex23)
            <=> v7525(VarNext,bitIndex991) )
            & ( v4933_27__array(VarNext,A,bitIndex22)
            <=> v7525(VarNext,bitIndex990) )
            & ( v4933_27__array(VarNext,A,bitIndex21)
            <=> v7525(VarNext,bitIndex989) )
            & ( v4933_27__array(VarNext,A,bitIndex20)
            <=> v7525(VarNext,bitIndex988) )
            & ( v4933_27__array(VarNext,A,bitIndex19)
            <=> v7525(VarNext,bitIndex987) )
            & ( v4933_27__array(VarNext,A,bitIndex18)
            <=> v7525(VarNext,bitIndex986) )
            & ( v4933_27__array(VarNext,A,bitIndex17)
            <=> v7525(VarNext,bitIndex985) )
            & ( v4933_27__array(VarNext,A,bitIndex16)
            <=> v7525(VarNext,bitIndex984) )
            & ( v4933_27__array(VarNext,A,bitIndex15)
            <=> v7525(VarNext,bitIndex983) )
            & ( v4933_27__array(VarNext,A,bitIndex14)
            <=> v7525(VarNext,bitIndex982) )
            & ( v4933_27__array(VarNext,A,bitIndex13)
            <=> v7525(VarNext,bitIndex981) )
            & ( v4933_27__array(VarNext,A,bitIndex12)
            <=> v7525(VarNext,bitIndex980) )
            & ( v4933_27__array(VarNext,A,bitIndex11)
            <=> v7525(VarNext,bitIndex979) )
            & ( v4933_27__array(VarNext,A,bitIndex10)
            <=> v7525(VarNext,bitIndex978) )
            & ( v4933_27__array(VarNext,A,bitIndex9)
            <=> v7525(VarNext,bitIndex977) )
            & ( v4933_27__array(VarNext,A,bitIndex8)
            <=> v7525(VarNext,bitIndex976) )
            & ( v4933_27__array(VarNext,A,bitIndex7)
            <=> v7525(VarNext,bitIndex975) )
            & ( v4933_27__array(VarNext,A,bitIndex6)
            <=> v7525(VarNext,bitIndex974) )
            & ( v4933_27__array(VarNext,A,bitIndex5)
            <=> v7525(VarNext,bitIndex973) )
            & ( v4933_27__array(VarNext,A,bitIndex4)
            <=> v7525(VarNext,bitIndex972) )
            & ( v4933_27__array(VarNext,A,bitIndex3)
            <=> v7525(VarNext,bitIndex971) )
            & ( v4933_27__array(VarNext,A,bitIndex2)
            <=> v7525(VarNext,bitIndex970) )
            & ( v4933_27__array(VarNext,A,bitIndex1)
            <=> v7525(VarNext,bitIndex969) )
            & ( v4933_27__array(VarNext,A,bitIndex0)
            <=> v7525(VarNext,bitIndex968) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1353,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7519(VarNext)
      <=> ( v7520(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1352,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7520(VarNext)
      <=> ( v7522(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_637,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7522(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_45,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10101_address_term = A
              & v7510(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_26__array(VarNext,A,B)
              <=> v4933_25__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_45,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10101_address_term = A
            & v7510(VarNext) )
         => ( ( v4933_26__array(VarNext,A,bitIndex43)
            <=> v7516(VarNext,bitIndex967) )
            & ( v4933_26__array(VarNext,A,bitIndex42)
            <=> v7516(VarNext,bitIndex966) )
            & ( v4933_26__array(VarNext,A,bitIndex41)
            <=> v7516(VarNext,bitIndex965) )
            & ( v4933_26__array(VarNext,A,bitIndex40)
            <=> v7516(VarNext,bitIndex964) )
            & ( v4933_26__array(VarNext,A,bitIndex39)
            <=> v7516(VarNext,bitIndex963) )
            & ( v4933_26__array(VarNext,A,bitIndex38)
            <=> v7516(VarNext,bitIndex962) )
            & ( v4933_26__array(VarNext,A,bitIndex37)
            <=> v7516(VarNext,bitIndex961) )
            & ( v4933_26__array(VarNext,A,bitIndex36)
            <=> v7516(VarNext,bitIndex960) )
            & ( v4933_26__array(VarNext,A,bitIndex35)
            <=> v7516(VarNext,bitIndex959) )
            & ( v4933_26__array(VarNext,A,bitIndex34)
            <=> v7516(VarNext,bitIndex958) )
            & ( v4933_26__array(VarNext,A,bitIndex33)
            <=> v7516(VarNext,bitIndex957) )
            & ( v4933_26__array(VarNext,A,bitIndex32)
            <=> v7516(VarNext,bitIndex956) )
            & ( v4933_26__array(VarNext,A,bitIndex31)
            <=> v7516(VarNext,bitIndex955) )
            & ( v4933_26__array(VarNext,A,bitIndex30)
            <=> v7516(VarNext,bitIndex954) )
            & ( v4933_26__array(VarNext,A,bitIndex29)
            <=> v7516(VarNext,bitIndex953) )
            & ( v4933_26__array(VarNext,A,bitIndex28)
            <=> v7516(VarNext,bitIndex952) )
            & ( v4933_26__array(VarNext,A,bitIndex27)
            <=> v7516(VarNext,bitIndex951) )
            & ( v4933_26__array(VarNext,A,bitIndex26)
            <=> v7516(VarNext,bitIndex950) )
            & ( v4933_26__array(VarNext,A,bitIndex25)
            <=> v7516(VarNext,bitIndex949) )
            & ( v4933_26__array(VarNext,A,bitIndex24)
            <=> v7516(VarNext,bitIndex948) )
            & ( v4933_26__array(VarNext,A,bitIndex23)
            <=> v7516(VarNext,bitIndex947) )
            & ( v4933_26__array(VarNext,A,bitIndex22)
            <=> v7516(VarNext,bitIndex946) )
            & ( v4933_26__array(VarNext,A,bitIndex21)
            <=> v7516(VarNext,bitIndex945) )
            & ( v4933_26__array(VarNext,A,bitIndex20)
            <=> v7516(VarNext,bitIndex944) )
            & ( v4933_26__array(VarNext,A,bitIndex19)
            <=> v7516(VarNext,bitIndex943) )
            & ( v4933_26__array(VarNext,A,bitIndex18)
            <=> v7516(VarNext,bitIndex942) )
            & ( v4933_26__array(VarNext,A,bitIndex17)
            <=> v7516(VarNext,bitIndex941) )
            & ( v4933_26__array(VarNext,A,bitIndex16)
            <=> v7516(VarNext,bitIndex940) )
            & ( v4933_26__array(VarNext,A,bitIndex15)
            <=> v7516(VarNext,bitIndex939) )
            & ( v4933_26__array(VarNext,A,bitIndex14)
            <=> v7516(VarNext,bitIndex938) )
            & ( v4933_26__array(VarNext,A,bitIndex13)
            <=> v7516(VarNext,bitIndex937) )
            & ( v4933_26__array(VarNext,A,bitIndex12)
            <=> v7516(VarNext,bitIndex936) )
            & ( v4933_26__array(VarNext,A,bitIndex11)
            <=> v7516(VarNext,bitIndex935) )
            & ( v4933_26__array(VarNext,A,bitIndex10)
            <=> v7516(VarNext,bitIndex934) )
            & ( v4933_26__array(VarNext,A,bitIndex9)
            <=> v7516(VarNext,bitIndex933) )
            & ( v4933_26__array(VarNext,A,bitIndex8)
            <=> v7516(VarNext,bitIndex932) )
            & ( v4933_26__array(VarNext,A,bitIndex7)
            <=> v7516(VarNext,bitIndex931) )
            & ( v4933_26__array(VarNext,A,bitIndex6)
            <=> v7516(VarNext,bitIndex930) )
            & ( v4933_26__array(VarNext,A,bitIndex5)
            <=> v7516(VarNext,bitIndex929) )
            & ( v4933_26__array(VarNext,A,bitIndex4)
            <=> v7516(VarNext,bitIndex928) )
            & ( v4933_26__array(VarNext,A,bitIndex3)
            <=> v7516(VarNext,bitIndex927) )
            & ( v4933_26__array(VarNext,A,bitIndex2)
            <=> v7516(VarNext,bitIndex926) )
            & ( v4933_26__array(VarNext,A,bitIndex1)
            <=> v7516(VarNext,bitIndex925) )
            & ( v4933_26__array(VarNext,A,bitIndex0)
            <=> v7516(VarNext,bitIndex924) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1351,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7510(VarNext)
      <=> ( v7511(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1350,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7511(VarNext)
      <=> ( v7513(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_636,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7513(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_44,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10100_address_term = A
              & v7501(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_25__array(VarNext,A,B)
              <=> v4933_24__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_44,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10100_address_term = A
            & v7501(VarNext) )
         => ( ( v4933_25__array(VarNext,A,bitIndex43)
            <=> v7507(VarNext,bitIndex923) )
            & ( v4933_25__array(VarNext,A,bitIndex42)
            <=> v7507(VarNext,bitIndex922) )
            & ( v4933_25__array(VarNext,A,bitIndex41)
            <=> v7507(VarNext,bitIndex921) )
            & ( v4933_25__array(VarNext,A,bitIndex40)
            <=> v7507(VarNext,bitIndex920) )
            & ( v4933_25__array(VarNext,A,bitIndex39)
            <=> v7507(VarNext,bitIndex919) )
            & ( v4933_25__array(VarNext,A,bitIndex38)
            <=> v7507(VarNext,bitIndex918) )
            & ( v4933_25__array(VarNext,A,bitIndex37)
            <=> v7507(VarNext,bitIndex917) )
            & ( v4933_25__array(VarNext,A,bitIndex36)
            <=> v7507(VarNext,bitIndex916) )
            & ( v4933_25__array(VarNext,A,bitIndex35)
            <=> v7507(VarNext,bitIndex915) )
            & ( v4933_25__array(VarNext,A,bitIndex34)
            <=> v7507(VarNext,bitIndex914) )
            & ( v4933_25__array(VarNext,A,bitIndex33)
            <=> v7507(VarNext,bitIndex913) )
            & ( v4933_25__array(VarNext,A,bitIndex32)
            <=> v7507(VarNext,bitIndex912) )
            & ( v4933_25__array(VarNext,A,bitIndex31)
            <=> v7507(VarNext,bitIndex911) )
            & ( v4933_25__array(VarNext,A,bitIndex30)
            <=> v7507(VarNext,bitIndex910) )
            & ( v4933_25__array(VarNext,A,bitIndex29)
            <=> v7507(VarNext,bitIndex909) )
            & ( v4933_25__array(VarNext,A,bitIndex28)
            <=> v7507(VarNext,bitIndex908) )
            & ( v4933_25__array(VarNext,A,bitIndex27)
            <=> v7507(VarNext,bitIndex907) )
            & ( v4933_25__array(VarNext,A,bitIndex26)
            <=> v7507(VarNext,bitIndex906) )
            & ( v4933_25__array(VarNext,A,bitIndex25)
            <=> v7507(VarNext,bitIndex905) )
            & ( v4933_25__array(VarNext,A,bitIndex24)
            <=> v7507(VarNext,bitIndex904) )
            & ( v4933_25__array(VarNext,A,bitIndex23)
            <=> v7507(VarNext,bitIndex903) )
            & ( v4933_25__array(VarNext,A,bitIndex22)
            <=> v7507(VarNext,bitIndex902) )
            & ( v4933_25__array(VarNext,A,bitIndex21)
            <=> v7507(VarNext,bitIndex901) )
            & ( v4933_25__array(VarNext,A,bitIndex20)
            <=> v7507(VarNext,bitIndex900) )
            & ( v4933_25__array(VarNext,A,bitIndex19)
            <=> v7507(VarNext,bitIndex899) )
            & ( v4933_25__array(VarNext,A,bitIndex18)
            <=> v7507(VarNext,bitIndex898) )
            & ( v4933_25__array(VarNext,A,bitIndex17)
            <=> v7507(VarNext,bitIndex897) )
            & ( v4933_25__array(VarNext,A,bitIndex16)
            <=> v7507(VarNext,bitIndex896) )
            & ( v4933_25__array(VarNext,A,bitIndex15)
            <=> v7507(VarNext,bitIndex895) )
            & ( v4933_25__array(VarNext,A,bitIndex14)
            <=> v7507(VarNext,bitIndex894) )
            & ( v4933_25__array(VarNext,A,bitIndex13)
            <=> v7507(VarNext,bitIndex893) )
            & ( v4933_25__array(VarNext,A,bitIndex12)
            <=> v7507(VarNext,bitIndex892) )
            & ( v4933_25__array(VarNext,A,bitIndex11)
            <=> v7507(VarNext,bitIndex891) )
            & ( v4933_25__array(VarNext,A,bitIndex10)
            <=> v7507(VarNext,bitIndex890) )
            & ( v4933_25__array(VarNext,A,bitIndex9)
            <=> v7507(VarNext,bitIndex889) )
            & ( v4933_25__array(VarNext,A,bitIndex8)
            <=> v7507(VarNext,bitIndex888) )
            & ( v4933_25__array(VarNext,A,bitIndex7)
            <=> v7507(VarNext,bitIndex887) )
            & ( v4933_25__array(VarNext,A,bitIndex6)
            <=> v7507(VarNext,bitIndex886) )
            & ( v4933_25__array(VarNext,A,bitIndex5)
            <=> v7507(VarNext,bitIndex885) )
            & ( v4933_25__array(VarNext,A,bitIndex4)
            <=> v7507(VarNext,bitIndex884) )
            & ( v4933_25__array(VarNext,A,bitIndex3)
            <=> v7507(VarNext,bitIndex883) )
            & ( v4933_25__array(VarNext,A,bitIndex2)
            <=> v7507(VarNext,bitIndex882) )
            & ( v4933_25__array(VarNext,A,bitIndex1)
            <=> v7507(VarNext,bitIndex881) )
            & ( v4933_25__array(VarNext,A,bitIndex0)
            <=> v7507(VarNext,bitIndex880) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1349,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7501(VarNext)
      <=> ( v7502(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1348,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7502(VarNext)
      <=> ( v7504(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_635,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7504(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_43,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10011_address_term = A
              & v7492(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_24__array(VarNext,A,B)
              <=> v4933_23__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_43,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10011_address_term = A
            & v7492(VarNext) )
         => ( ( v4933_24__array(VarNext,A,bitIndex43)
            <=> v7498(VarNext,bitIndex879) )
            & ( v4933_24__array(VarNext,A,bitIndex42)
            <=> v7498(VarNext,bitIndex878) )
            & ( v4933_24__array(VarNext,A,bitIndex41)
            <=> v7498(VarNext,bitIndex877) )
            & ( v4933_24__array(VarNext,A,bitIndex40)
            <=> v7498(VarNext,bitIndex876) )
            & ( v4933_24__array(VarNext,A,bitIndex39)
            <=> v7498(VarNext,bitIndex875) )
            & ( v4933_24__array(VarNext,A,bitIndex38)
            <=> v7498(VarNext,bitIndex874) )
            & ( v4933_24__array(VarNext,A,bitIndex37)
            <=> v7498(VarNext,bitIndex873) )
            & ( v4933_24__array(VarNext,A,bitIndex36)
            <=> v7498(VarNext,bitIndex872) )
            & ( v4933_24__array(VarNext,A,bitIndex35)
            <=> v7498(VarNext,bitIndex871) )
            & ( v4933_24__array(VarNext,A,bitIndex34)
            <=> v7498(VarNext,bitIndex870) )
            & ( v4933_24__array(VarNext,A,bitIndex33)
            <=> v7498(VarNext,bitIndex869) )
            & ( v4933_24__array(VarNext,A,bitIndex32)
            <=> v7498(VarNext,bitIndex868) )
            & ( v4933_24__array(VarNext,A,bitIndex31)
            <=> v7498(VarNext,bitIndex867) )
            & ( v4933_24__array(VarNext,A,bitIndex30)
            <=> v7498(VarNext,bitIndex866) )
            & ( v4933_24__array(VarNext,A,bitIndex29)
            <=> v7498(VarNext,bitIndex865) )
            & ( v4933_24__array(VarNext,A,bitIndex28)
            <=> v7498(VarNext,bitIndex864) )
            & ( v4933_24__array(VarNext,A,bitIndex27)
            <=> v7498(VarNext,bitIndex863) )
            & ( v4933_24__array(VarNext,A,bitIndex26)
            <=> v7498(VarNext,bitIndex862) )
            & ( v4933_24__array(VarNext,A,bitIndex25)
            <=> v7498(VarNext,bitIndex861) )
            & ( v4933_24__array(VarNext,A,bitIndex24)
            <=> v7498(VarNext,bitIndex860) )
            & ( v4933_24__array(VarNext,A,bitIndex23)
            <=> v7498(VarNext,bitIndex859) )
            & ( v4933_24__array(VarNext,A,bitIndex22)
            <=> v7498(VarNext,bitIndex858) )
            & ( v4933_24__array(VarNext,A,bitIndex21)
            <=> v7498(VarNext,bitIndex857) )
            & ( v4933_24__array(VarNext,A,bitIndex20)
            <=> v7498(VarNext,bitIndex856) )
            & ( v4933_24__array(VarNext,A,bitIndex19)
            <=> v7498(VarNext,bitIndex855) )
            & ( v4933_24__array(VarNext,A,bitIndex18)
            <=> v7498(VarNext,bitIndex854) )
            & ( v4933_24__array(VarNext,A,bitIndex17)
            <=> v7498(VarNext,bitIndex853) )
            & ( v4933_24__array(VarNext,A,bitIndex16)
            <=> v7498(VarNext,bitIndex852) )
            & ( v4933_24__array(VarNext,A,bitIndex15)
            <=> v7498(VarNext,bitIndex851) )
            & ( v4933_24__array(VarNext,A,bitIndex14)
            <=> v7498(VarNext,bitIndex850) )
            & ( v4933_24__array(VarNext,A,bitIndex13)
            <=> v7498(VarNext,bitIndex849) )
            & ( v4933_24__array(VarNext,A,bitIndex12)
            <=> v7498(VarNext,bitIndex848) )
            & ( v4933_24__array(VarNext,A,bitIndex11)
            <=> v7498(VarNext,bitIndex847) )
            & ( v4933_24__array(VarNext,A,bitIndex10)
            <=> v7498(VarNext,bitIndex846) )
            & ( v4933_24__array(VarNext,A,bitIndex9)
            <=> v7498(VarNext,bitIndex845) )
            & ( v4933_24__array(VarNext,A,bitIndex8)
            <=> v7498(VarNext,bitIndex844) )
            & ( v4933_24__array(VarNext,A,bitIndex7)
            <=> v7498(VarNext,bitIndex843) )
            & ( v4933_24__array(VarNext,A,bitIndex6)
            <=> v7498(VarNext,bitIndex842) )
            & ( v4933_24__array(VarNext,A,bitIndex5)
            <=> v7498(VarNext,bitIndex841) )
            & ( v4933_24__array(VarNext,A,bitIndex4)
            <=> v7498(VarNext,bitIndex840) )
            & ( v4933_24__array(VarNext,A,bitIndex3)
            <=> v7498(VarNext,bitIndex839) )
            & ( v4933_24__array(VarNext,A,bitIndex2)
            <=> v7498(VarNext,bitIndex838) )
            & ( v4933_24__array(VarNext,A,bitIndex1)
            <=> v7498(VarNext,bitIndex837) )
            & ( v4933_24__array(VarNext,A,bitIndex0)
            <=> v7498(VarNext,bitIndex836) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1347,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7492(VarNext)
      <=> ( v7493(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1346,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7493(VarNext)
      <=> ( v7495(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_634,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7495(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_42,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10010_address_term = A
              & v7483(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_23__array(VarNext,A,B)
              <=> v4933_22__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_42,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10010_address_term = A
            & v7483(VarNext) )
         => ( ( v4933_23__array(VarNext,A,bitIndex43)
            <=> v7489(VarNext,bitIndex835) )
            & ( v4933_23__array(VarNext,A,bitIndex42)
            <=> v7489(VarNext,bitIndex834) )
            & ( v4933_23__array(VarNext,A,bitIndex41)
            <=> v7489(VarNext,bitIndex833) )
            & ( v4933_23__array(VarNext,A,bitIndex40)
            <=> v7489(VarNext,bitIndex832) )
            & ( v4933_23__array(VarNext,A,bitIndex39)
            <=> v7489(VarNext,bitIndex831) )
            & ( v4933_23__array(VarNext,A,bitIndex38)
            <=> v7489(VarNext,bitIndex830) )
            & ( v4933_23__array(VarNext,A,bitIndex37)
            <=> v7489(VarNext,bitIndex829) )
            & ( v4933_23__array(VarNext,A,bitIndex36)
            <=> v7489(VarNext,bitIndex828) )
            & ( v4933_23__array(VarNext,A,bitIndex35)
            <=> v7489(VarNext,bitIndex827) )
            & ( v4933_23__array(VarNext,A,bitIndex34)
            <=> v7489(VarNext,bitIndex826) )
            & ( v4933_23__array(VarNext,A,bitIndex33)
            <=> v7489(VarNext,bitIndex825) )
            & ( v4933_23__array(VarNext,A,bitIndex32)
            <=> v7489(VarNext,bitIndex824) )
            & ( v4933_23__array(VarNext,A,bitIndex31)
            <=> v7489(VarNext,bitIndex823) )
            & ( v4933_23__array(VarNext,A,bitIndex30)
            <=> v7489(VarNext,bitIndex822) )
            & ( v4933_23__array(VarNext,A,bitIndex29)
            <=> v7489(VarNext,bitIndex821) )
            & ( v4933_23__array(VarNext,A,bitIndex28)
            <=> v7489(VarNext,bitIndex820) )
            & ( v4933_23__array(VarNext,A,bitIndex27)
            <=> v7489(VarNext,bitIndex819) )
            & ( v4933_23__array(VarNext,A,bitIndex26)
            <=> v7489(VarNext,bitIndex818) )
            & ( v4933_23__array(VarNext,A,bitIndex25)
            <=> v7489(VarNext,bitIndex817) )
            & ( v4933_23__array(VarNext,A,bitIndex24)
            <=> v7489(VarNext,bitIndex816) )
            & ( v4933_23__array(VarNext,A,bitIndex23)
            <=> v7489(VarNext,bitIndex815) )
            & ( v4933_23__array(VarNext,A,bitIndex22)
            <=> v7489(VarNext,bitIndex814) )
            & ( v4933_23__array(VarNext,A,bitIndex21)
            <=> v7489(VarNext,bitIndex813) )
            & ( v4933_23__array(VarNext,A,bitIndex20)
            <=> v7489(VarNext,bitIndex812) )
            & ( v4933_23__array(VarNext,A,bitIndex19)
            <=> v7489(VarNext,bitIndex811) )
            & ( v4933_23__array(VarNext,A,bitIndex18)
            <=> v7489(VarNext,bitIndex810) )
            & ( v4933_23__array(VarNext,A,bitIndex17)
            <=> v7489(VarNext,bitIndex809) )
            & ( v4933_23__array(VarNext,A,bitIndex16)
            <=> v7489(VarNext,bitIndex808) )
            & ( v4933_23__array(VarNext,A,bitIndex15)
            <=> v7489(VarNext,bitIndex807) )
            & ( v4933_23__array(VarNext,A,bitIndex14)
            <=> v7489(VarNext,bitIndex806) )
            & ( v4933_23__array(VarNext,A,bitIndex13)
            <=> v7489(VarNext,bitIndex805) )
            & ( v4933_23__array(VarNext,A,bitIndex12)
            <=> v7489(VarNext,bitIndex804) )
            & ( v4933_23__array(VarNext,A,bitIndex11)
            <=> v7489(VarNext,bitIndex803) )
            & ( v4933_23__array(VarNext,A,bitIndex10)
            <=> v7489(VarNext,bitIndex802) )
            & ( v4933_23__array(VarNext,A,bitIndex9)
            <=> v7489(VarNext,bitIndex801) )
            & ( v4933_23__array(VarNext,A,bitIndex8)
            <=> v7489(VarNext,bitIndex800) )
            & ( v4933_23__array(VarNext,A,bitIndex7)
            <=> v7489(VarNext,bitIndex799) )
            & ( v4933_23__array(VarNext,A,bitIndex6)
            <=> v7489(VarNext,bitIndex798) )
            & ( v4933_23__array(VarNext,A,bitIndex5)
            <=> v7489(VarNext,bitIndex797) )
            & ( v4933_23__array(VarNext,A,bitIndex4)
            <=> v7489(VarNext,bitIndex796) )
            & ( v4933_23__array(VarNext,A,bitIndex3)
            <=> v7489(VarNext,bitIndex795) )
            & ( v4933_23__array(VarNext,A,bitIndex2)
            <=> v7489(VarNext,bitIndex794) )
            & ( v4933_23__array(VarNext,A,bitIndex1)
            <=> v7489(VarNext,bitIndex793) )
            & ( v4933_23__array(VarNext,A,bitIndex0)
            <=> v7489(VarNext,bitIndex792) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1345,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7483(VarNext)
      <=> ( v7484(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1344,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7484(VarNext)
      <=> ( v7486(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_633,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7486(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_41,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10001_address_term = A
              & v7474(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_22__array(VarNext,A,B)
              <=> v4933_21__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_41,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10001_address_term = A
            & v7474(VarNext) )
         => ( ( v4933_22__array(VarNext,A,bitIndex43)
            <=> v7480(VarNext,bitIndex791) )
            & ( v4933_22__array(VarNext,A,bitIndex42)
            <=> v7480(VarNext,bitIndex790) )
            & ( v4933_22__array(VarNext,A,bitIndex41)
            <=> v7480(VarNext,bitIndex789) )
            & ( v4933_22__array(VarNext,A,bitIndex40)
            <=> v7480(VarNext,bitIndex788) )
            & ( v4933_22__array(VarNext,A,bitIndex39)
            <=> v7480(VarNext,bitIndex787) )
            & ( v4933_22__array(VarNext,A,bitIndex38)
            <=> v7480(VarNext,bitIndex786) )
            & ( v4933_22__array(VarNext,A,bitIndex37)
            <=> v7480(VarNext,bitIndex785) )
            & ( v4933_22__array(VarNext,A,bitIndex36)
            <=> v7480(VarNext,bitIndex784) )
            & ( v4933_22__array(VarNext,A,bitIndex35)
            <=> v7480(VarNext,bitIndex783) )
            & ( v4933_22__array(VarNext,A,bitIndex34)
            <=> v7480(VarNext,bitIndex782) )
            & ( v4933_22__array(VarNext,A,bitIndex33)
            <=> v7480(VarNext,bitIndex781) )
            & ( v4933_22__array(VarNext,A,bitIndex32)
            <=> v7480(VarNext,bitIndex780) )
            & ( v4933_22__array(VarNext,A,bitIndex31)
            <=> v7480(VarNext,bitIndex779) )
            & ( v4933_22__array(VarNext,A,bitIndex30)
            <=> v7480(VarNext,bitIndex778) )
            & ( v4933_22__array(VarNext,A,bitIndex29)
            <=> v7480(VarNext,bitIndex777) )
            & ( v4933_22__array(VarNext,A,bitIndex28)
            <=> v7480(VarNext,bitIndex776) )
            & ( v4933_22__array(VarNext,A,bitIndex27)
            <=> v7480(VarNext,bitIndex775) )
            & ( v4933_22__array(VarNext,A,bitIndex26)
            <=> v7480(VarNext,bitIndex774) )
            & ( v4933_22__array(VarNext,A,bitIndex25)
            <=> v7480(VarNext,bitIndex773) )
            & ( v4933_22__array(VarNext,A,bitIndex24)
            <=> v7480(VarNext,bitIndex772) )
            & ( v4933_22__array(VarNext,A,bitIndex23)
            <=> v7480(VarNext,bitIndex771) )
            & ( v4933_22__array(VarNext,A,bitIndex22)
            <=> v7480(VarNext,bitIndex770) )
            & ( v4933_22__array(VarNext,A,bitIndex21)
            <=> v7480(VarNext,bitIndex769) )
            & ( v4933_22__array(VarNext,A,bitIndex20)
            <=> v7480(VarNext,bitIndex768) )
            & ( v4933_22__array(VarNext,A,bitIndex19)
            <=> v7480(VarNext,bitIndex767) )
            & ( v4933_22__array(VarNext,A,bitIndex18)
            <=> v7480(VarNext,bitIndex766) )
            & ( v4933_22__array(VarNext,A,bitIndex17)
            <=> v7480(VarNext,bitIndex765) )
            & ( v4933_22__array(VarNext,A,bitIndex16)
            <=> v7480(VarNext,bitIndex764) )
            & ( v4933_22__array(VarNext,A,bitIndex15)
            <=> v7480(VarNext,bitIndex763) )
            & ( v4933_22__array(VarNext,A,bitIndex14)
            <=> v7480(VarNext,bitIndex762) )
            & ( v4933_22__array(VarNext,A,bitIndex13)
            <=> v7480(VarNext,bitIndex761) )
            & ( v4933_22__array(VarNext,A,bitIndex12)
            <=> v7480(VarNext,bitIndex760) )
            & ( v4933_22__array(VarNext,A,bitIndex11)
            <=> v7480(VarNext,bitIndex759) )
            & ( v4933_22__array(VarNext,A,bitIndex10)
            <=> v7480(VarNext,bitIndex758) )
            & ( v4933_22__array(VarNext,A,bitIndex9)
            <=> v7480(VarNext,bitIndex757) )
            & ( v4933_22__array(VarNext,A,bitIndex8)
            <=> v7480(VarNext,bitIndex756) )
            & ( v4933_22__array(VarNext,A,bitIndex7)
            <=> v7480(VarNext,bitIndex755) )
            & ( v4933_22__array(VarNext,A,bitIndex6)
            <=> v7480(VarNext,bitIndex754) )
            & ( v4933_22__array(VarNext,A,bitIndex5)
            <=> v7480(VarNext,bitIndex753) )
            & ( v4933_22__array(VarNext,A,bitIndex4)
            <=> v7480(VarNext,bitIndex752) )
            & ( v4933_22__array(VarNext,A,bitIndex3)
            <=> v7480(VarNext,bitIndex751) )
            & ( v4933_22__array(VarNext,A,bitIndex2)
            <=> v7480(VarNext,bitIndex750) )
            & ( v4933_22__array(VarNext,A,bitIndex1)
            <=> v7480(VarNext,bitIndex749) )
            & ( v4933_22__array(VarNext,A,bitIndex0)
            <=> v7480(VarNext,bitIndex748) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1343,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7474(VarNext)
      <=> ( v7475(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1342,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7475(VarNext)
      <=> ( v7477(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_632,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7477(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_40,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b10000_address_term = A
              & v7465(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_21__array(VarNext,A,B)
              <=> v4933_20__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_40,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b10000_address_term = A
            & v7465(VarNext) )
         => ( ( v4933_21__array(VarNext,A,bitIndex43)
            <=> v7471(VarNext,bitIndex747) )
            & ( v4933_21__array(VarNext,A,bitIndex42)
            <=> v7471(VarNext,bitIndex746) )
            & ( v4933_21__array(VarNext,A,bitIndex41)
            <=> v7471(VarNext,bitIndex745) )
            & ( v4933_21__array(VarNext,A,bitIndex40)
            <=> v7471(VarNext,bitIndex744) )
            & ( v4933_21__array(VarNext,A,bitIndex39)
            <=> v7471(VarNext,bitIndex743) )
            & ( v4933_21__array(VarNext,A,bitIndex38)
            <=> v7471(VarNext,bitIndex742) )
            & ( v4933_21__array(VarNext,A,bitIndex37)
            <=> v7471(VarNext,bitIndex741) )
            & ( v4933_21__array(VarNext,A,bitIndex36)
            <=> v7471(VarNext,bitIndex740) )
            & ( v4933_21__array(VarNext,A,bitIndex35)
            <=> v7471(VarNext,bitIndex739) )
            & ( v4933_21__array(VarNext,A,bitIndex34)
            <=> v7471(VarNext,bitIndex738) )
            & ( v4933_21__array(VarNext,A,bitIndex33)
            <=> v7471(VarNext,bitIndex737) )
            & ( v4933_21__array(VarNext,A,bitIndex32)
            <=> v7471(VarNext,bitIndex736) )
            & ( v4933_21__array(VarNext,A,bitIndex31)
            <=> v7471(VarNext,bitIndex735) )
            & ( v4933_21__array(VarNext,A,bitIndex30)
            <=> v7471(VarNext,bitIndex734) )
            & ( v4933_21__array(VarNext,A,bitIndex29)
            <=> v7471(VarNext,bitIndex733) )
            & ( v4933_21__array(VarNext,A,bitIndex28)
            <=> v7471(VarNext,bitIndex732) )
            & ( v4933_21__array(VarNext,A,bitIndex27)
            <=> v7471(VarNext,bitIndex731) )
            & ( v4933_21__array(VarNext,A,bitIndex26)
            <=> v7471(VarNext,bitIndex730) )
            & ( v4933_21__array(VarNext,A,bitIndex25)
            <=> v7471(VarNext,bitIndex729) )
            & ( v4933_21__array(VarNext,A,bitIndex24)
            <=> v7471(VarNext,bitIndex728) )
            & ( v4933_21__array(VarNext,A,bitIndex23)
            <=> v7471(VarNext,bitIndex727) )
            & ( v4933_21__array(VarNext,A,bitIndex22)
            <=> v7471(VarNext,bitIndex726) )
            & ( v4933_21__array(VarNext,A,bitIndex21)
            <=> v7471(VarNext,bitIndex725) )
            & ( v4933_21__array(VarNext,A,bitIndex20)
            <=> v7471(VarNext,bitIndex724) )
            & ( v4933_21__array(VarNext,A,bitIndex19)
            <=> v7471(VarNext,bitIndex723) )
            & ( v4933_21__array(VarNext,A,bitIndex18)
            <=> v7471(VarNext,bitIndex722) )
            & ( v4933_21__array(VarNext,A,bitIndex17)
            <=> v7471(VarNext,bitIndex721) )
            & ( v4933_21__array(VarNext,A,bitIndex16)
            <=> v7471(VarNext,bitIndex720) )
            & ( v4933_21__array(VarNext,A,bitIndex15)
            <=> v7471(VarNext,bitIndex719) )
            & ( v4933_21__array(VarNext,A,bitIndex14)
            <=> v7471(VarNext,bitIndex718) )
            & ( v4933_21__array(VarNext,A,bitIndex13)
            <=> v7471(VarNext,bitIndex717) )
            & ( v4933_21__array(VarNext,A,bitIndex12)
            <=> v7471(VarNext,bitIndex716) )
            & ( v4933_21__array(VarNext,A,bitIndex11)
            <=> v7471(VarNext,bitIndex715) )
            & ( v4933_21__array(VarNext,A,bitIndex10)
            <=> v7471(VarNext,bitIndex714) )
            & ( v4933_21__array(VarNext,A,bitIndex9)
            <=> v7471(VarNext,bitIndex713) )
            & ( v4933_21__array(VarNext,A,bitIndex8)
            <=> v7471(VarNext,bitIndex712) )
            & ( v4933_21__array(VarNext,A,bitIndex7)
            <=> v7471(VarNext,bitIndex711) )
            & ( v4933_21__array(VarNext,A,bitIndex6)
            <=> v7471(VarNext,bitIndex710) )
            & ( v4933_21__array(VarNext,A,bitIndex5)
            <=> v7471(VarNext,bitIndex709) )
            & ( v4933_21__array(VarNext,A,bitIndex4)
            <=> v7471(VarNext,bitIndex708) )
            & ( v4933_21__array(VarNext,A,bitIndex3)
            <=> v7471(VarNext,bitIndex707) )
            & ( v4933_21__array(VarNext,A,bitIndex2)
            <=> v7471(VarNext,bitIndex706) )
            & ( v4933_21__array(VarNext,A,bitIndex1)
            <=> v7471(VarNext,bitIndex705) )
            & ( v4933_21__array(VarNext,A,bitIndex0)
            <=> v7471(VarNext,bitIndex704) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1341,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7465(VarNext)
      <=> ( v7466(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1340,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7466(VarNext)
      <=> ( v7468(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_631,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7468(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_39,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01111_address_term = A
              & v7456(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_20__array(VarNext,A,B)
              <=> v4933_19__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_39,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01111_address_term = A
            & v7456(VarNext) )
         => ( ( v4933_20__array(VarNext,A,bitIndex43)
            <=> v7462(VarNext,bitIndex703) )
            & ( v4933_20__array(VarNext,A,bitIndex42)
            <=> v7462(VarNext,bitIndex702) )
            & ( v4933_20__array(VarNext,A,bitIndex41)
            <=> v7462(VarNext,bitIndex701) )
            & ( v4933_20__array(VarNext,A,bitIndex40)
            <=> v7462(VarNext,bitIndex700) )
            & ( v4933_20__array(VarNext,A,bitIndex39)
            <=> v7462(VarNext,bitIndex699) )
            & ( v4933_20__array(VarNext,A,bitIndex38)
            <=> v7462(VarNext,bitIndex698) )
            & ( v4933_20__array(VarNext,A,bitIndex37)
            <=> v7462(VarNext,bitIndex697) )
            & ( v4933_20__array(VarNext,A,bitIndex36)
            <=> v7462(VarNext,bitIndex696) )
            & ( v4933_20__array(VarNext,A,bitIndex35)
            <=> v7462(VarNext,bitIndex695) )
            & ( v4933_20__array(VarNext,A,bitIndex34)
            <=> v7462(VarNext,bitIndex694) )
            & ( v4933_20__array(VarNext,A,bitIndex33)
            <=> v7462(VarNext,bitIndex693) )
            & ( v4933_20__array(VarNext,A,bitIndex32)
            <=> v7462(VarNext,bitIndex692) )
            & ( v4933_20__array(VarNext,A,bitIndex31)
            <=> v7462(VarNext,bitIndex691) )
            & ( v4933_20__array(VarNext,A,bitIndex30)
            <=> v7462(VarNext,bitIndex690) )
            & ( v4933_20__array(VarNext,A,bitIndex29)
            <=> v7462(VarNext,bitIndex689) )
            & ( v4933_20__array(VarNext,A,bitIndex28)
            <=> v7462(VarNext,bitIndex688) )
            & ( v4933_20__array(VarNext,A,bitIndex27)
            <=> v7462(VarNext,bitIndex687) )
            & ( v4933_20__array(VarNext,A,bitIndex26)
            <=> v7462(VarNext,bitIndex686) )
            & ( v4933_20__array(VarNext,A,bitIndex25)
            <=> v7462(VarNext,bitIndex685) )
            & ( v4933_20__array(VarNext,A,bitIndex24)
            <=> v7462(VarNext,bitIndex684) )
            & ( v4933_20__array(VarNext,A,bitIndex23)
            <=> v7462(VarNext,bitIndex683) )
            & ( v4933_20__array(VarNext,A,bitIndex22)
            <=> v7462(VarNext,bitIndex682) )
            & ( v4933_20__array(VarNext,A,bitIndex21)
            <=> v7462(VarNext,bitIndex681) )
            & ( v4933_20__array(VarNext,A,bitIndex20)
            <=> v7462(VarNext,bitIndex680) )
            & ( v4933_20__array(VarNext,A,bitIndex19)
            <=> v7462(VarNext,bitIndex679) )
            & ( v4933_20__array(VarNext,A,bitIndex18)
            <=> v7462(VarNext,bitIndex678) )
            & ( v4933_20__array(VarNext,A,bitIndex17)
            <=> v7462(VarNext,bitIndex677) )
            & ( v4933_20__array(VarNext,A,bitIndex16)
            <=> v7462(VarNext,bitIndex676) )
            & ( v4933_20__array(VarNext,A,bitIndex15)
            <=> v7462(VarNext,bitIndex675) )
            & ( v4933_20__array(VarNext,A,bitIndex14)
            <=> v7462(VarNext,bitIndex674) )
            & ( v4933_20__array(VarNext,A,bitIndex13)
            <=> v7462(VarNext,bitIndex673) )
            & ( v4933_20__array(VarNext,A,bitIndex12)
            <=> v7462(VarNext,bitIndex672) )
            & ( v4933_20__array(VarNext,A,bitIndex11)
            <=> v7462(VarNext,bitIndex671) )
            & ( v4933_20__array(VarNext,A,bitIndex10)
            <=> v7462(VarNext,bitIndex670) )
            & ( v4933_20__array(VarNext,A,bitIndex9)
            <=> v7462(VarNext,bitIndex669) )
            & ( v4933_20__array(VarNext,A,bitIndex8)
            <=> v7462(VarNext,bitIndex668) )
            & ( v4933_20__array(VarNext,A,bitIndex7)
            <=> v7462(VarNext,bitIndex667) )
            & ( v4933_20__array(VarNext,A,bitIndex6)
            <=> v7462(VarNext,bitIndex666) )
            & ( v4933_20__array(VarNext,A,bitIndex5)
            <=> v7462(VarNext,bitIndex665) )
            & ( v4933_20__array(VarNext,A,bitIndex4)
            <=> v7462(VarNext,bitIndex664) )
            & ( v4933_20__array(VarNext,A,bitIndex3)
            <=> v7462(VarNext,bitIndex663) )
            & ( v4933_20__array(VarNext,A,bitIndex2)
            <=> v7462(VarNext,bitIndex662) )
            & ( v4933_20__array(VarNext,A,bitIndex1)
            <=> v7462(VarNext,bitIndex661) )
            & ( v4933_20__array(VarNext,A,bitIndex0)
            <=> v7462(VarNext,bitIndex660) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1339,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7456(VarNext)
      <=> ( v7457(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1338,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7457(VarNext)
      <=> ( v7459(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_630,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7459(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_38,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01110_address_term = A
              & v7447(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_19__array(VarNext,A,B)
              <=> v4933_18__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_38,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01110_address_term = A
            & v7447(VarNext) )
         => ( ( v4933_19__array(VarNext,A,bitIndex43)
            <=> v7453(VarNext,bitIndex659) )
            & ( v4933_19__array(VarNext,A,bitIndex42)
            <=> v7453(VarNext,bitIndex658) )
            & ( v4933_19__array(VarNext,A,bitIndex41)
            <=> v7453(VarNext,bitIndex657) )
            & ( v4933_19__array(VarNext,A,bitIndex40)
            <=> v7453(VarNext,bitIndex656) )
            & ( v4933_19__array(VarNext,A,bitIndex39)
            <=> v7453(VarNext,bitIndex655) )
            & ( v4933_19__array(VarNext,A,bitIndex38)
            <=> v7453(VarNext,bitIndex654) )
            & ( v4933_19__array(VarNext,A,bitIndex37)
            <=> v7453(VarNext,bitIndex653) )
            & ( v4933_19__array(VarNext,A,bitIndex36)
            <=> v7453(VarNext,bitIndex652) )
            & ( v4933_19__array(VarNext,A,bitIndex35)
            <=> v7453(VarNext,bitIndex651) )
            & ( v4933_19__array(VarNext,A,bitIndex34)
            <=> v7453(VarNext,bitIndex650) )
            & ( v4933_19__array(VarNext,A,bitIndex33)
            <=> v7453(VarNext,bitIndex649) )
            & ( v4933_19__array(VarNext,A,bitIndex32)
            <=> v7453(VarNext,bitIndex648) )
            & ( v4933_19__array(VarNext,A,bitIndex31)
            <=> v7453(VarNext,bitIndex647) )
            & ( v4933_19__array(VarNext,A,bitIndex30)
            <=> v7453(VarNext,bitIndex646) )
            & ( v4933_19__array(VarNext,A,bitIndex29)
            <=> v7453(VarNext,bitIndex645) )
            & ( v4933_19__array(VarNext,A,bitIndex28)
            <=> v7453(VarNext,bitIndex644) )
            & ( v4933_19__array(VarNext,A,bitIndex27)
            <=> v7453(VarNext,bitIndex643) )
            & ( v4933_19__array(VarNext,A,bitIndex26)
            <=> v7453(VarNext,bitIndex642) )
            & ( v4933_19__array(VarNext,A,bitIndex25)
            <=> v7453(VarNext,bitIndex641) )
            & ( v4933_19__array(VarNext,A,bitIndex24)
            <=> v7453(VarNext,bitIndex640) )
            & ( v4933_19__array(VarNext,A,bitIndex23)
            <=> v7453(VarNext,bitIndex639) )
            & ( v4933_19__array(VarNext,A,bitIndex22)
            <=> v7453(VarNext,bitIndex638) )
            & ( v4933_19__array(VarNext,A,bitIndex21)
            <=> v7453(VarNext,bitIndex637) )
            & ( v4933_19__array(VarNext,A,bitIndex20)
            <=> v7453(VarNext,bitIndex636) )
            & ( v4933_19__array(VarNext,A,bitIndex19)
            <=> v7453(VarNext,bitIndex635) )
            & ( v4933_19__array(VarNext,A,bitIndex18)
            <=> v7453(VarNext,bitIndex634) )
            & ( v4933_19__array(VarNext,A,bitIndex17)
            <=> v7453(VarNext,bitIndex633) )
            & ( v4933_19__array(VarNext,A,bitIndex16)
            <=> v7453(VarNext,bitIndex632) )
            & ( v4933_19__array(VarNext,A,bitIndex15)
            <=> v7453(VarNext,bitIndex631) )
            & ( v4933_19__array(VarNext,A,bitIndex14)
            <=> v7453(VarNext,bitIndex630) )
            & ( v4933_19__array(VarNext,A,bitIndex13)
            <=> v7453(VarNext,bitIndex629) )
            & ( v4933_19__array(VarNext,A,bitIndex12)
            <=> v7453(VarNext,bitIndex628) )
            & ( v4933_19__array(VarNext,A,bitIndex11)
            <=> v7453(VarNext,bitIndex627) )
            & ( v4933_19__array(VarNext,A,bitIndex10)
            <=> v7453(VarNext,bitIndex626) )
            & ( v4933_19__array(VarNext,A,bitIndex9)
            <=> v7453(VarNext,bitIndex625) )
            & ( v4933_19__array(VarNext,A,bitIndex8)
            <=> v7453(VarNext,bitIndex624) )
            & ( v4933_19__array(VarNext,A,bitIndex7)
            <=> v7453(VarNext,bitIndex623) )
            & ( v4933_19__array(VarNext,A,bitIndex6)
            <=> v7453(VarNext,bitIndex622) )
            & ( v4933_19__array(VarNext,A,bitIndex5)
            <=> v7453(VarNext,bitIndex621) )
            & ( v4933_19__array(VarNext,A,bitIndex4)
            <=> v7453(VarNext,bitIndex620) )
            & ( v4933_19__array(VarNext,A,bitIndex3)
            <=> v7453(VarNext,bitIndex619) )
            & ( v4933_19__array(VarNext,A,bitIndex2)
            <=> v7453(VarNext,bitIndex618) )
            & ( v4933_19__array(VarNext,A,bitIndex1)
            <=> v7453(VarNext,bitIndex617) )
            & ( v4933_19__array(VarNext,A,bitIndex0)
            <=> v7453(VarNext,bitIndex616) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1337,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7447(VarNext)
      <=> ( v7448(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1336,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7448(VarNext)
      <=> ( v7450(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_629,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7450(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_37,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01101_address_term = A
              & v7438(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_18__array(VarNext,A,B)
              <=> v4933_17__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_37,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01101_address_term = A
            & v7438(VarNext) )
         => ( ( v4933_18__array(VarNext,A,bitIndex43)
            <=> v7444(VarNext,bitIndex615) )
            & ( v4933_18__array(VarNext,A,bitIndex42)
            <=> v7444(VarNext,bitIndex614) )
            & ( v4933_18__array(VarNext,A,bitIndex41)
            <=> v7444(VarNext,bitIndex613) )
            & ( v4933_18__array(VarNext,A,bitIndex40)
            <=> v7444(VarNext,bitIndex612) )
            & ( v4933_18__array(VarNext,A,bitIndex39)
            <=> v7444(VarNext,bitIndex611) )
            & ( v4933_18__array(VarNext,A,bitIndex38)
            <=> v7444(VarNext,bitIndex610) )
            & ( v4933_18__array(VarNext,A,bitIndex37)
            <=> v7444(VarNext,bitIndex609) )
            & ( v4933_18__array(VarNext,A,bitIndex36)
            <=> v7444(VarNext,bitIndex608) )
            & ( v4933_18__array(VarNext,A,bitIndex35)
            <=> v7444(VarNext,bitIndex607) )
            & ( v4933_18__array(VarNext,A,bitIndex34)
            <=> v7444(VarNext,bitIndex606) )
            & ( v4933_18__array(VarNext,A,bitIndex33)
            <=> v7444(VarNext,bitIndex605) )
            & ( v4933_18__array(VarNext,A,bitIndex32)
            <=> v7444(VarNext,bitIndex604) )
            & ( v4933_18__array(VarNext,A,bitIndex31)
            <=> v7444(VarNext,bitIndex603) )
            & ( v4933_18__array(VarNext,A,bitIndex30)
            <=> v7444(VarNext,bitIndex602) )
            & ( v4933_18__array(VarNext,A,bitIndex29)
            <=> v7444(VarNext,bitIndex601) )
            & ( v4933_18__array(VarNext,A,bitIndex28)
            <=> v7444(VarNext,bitIndex600) )
            & ( v4933_18__array(VarNext,A,bitIndex27)
            <=> v7444(VarNext,bitIndex599) )
            & ( v4933_18__array(VarNext,A,bitIndex26)
            <=> v7444(VarNext,bitIndex598) )
            & ( v4933_18__array(VarNext,A,bitIndex25)
            <=> v7444(VarNext,bitIndex597) )
            & ( v4933_18__array(VarNext,A,bitIndex24)
            <=> v7444(VarNext,bitIndex596) )
            & ( v4933_18__array(VarNext,A,bitIndex23)
            <=> v7444(VarNext,bitIndex595) )
            & ( v4933_18__array(VarNext,A,bitIndex22)
            <=> v7444(VarNext,bitIndex594) )
            & ( v4933_18__array(VarNext,A,bitIndex21)
            <=> v7444(VarNext,bitIndex593) )
            & ( v4933_18__array(VarNext,A,bitIndex20)
            <=> v7444(VarNext,bitIndex592) )
            & ( v4933_18__array(VarNext,A,bitIndex19)
            <=> v7444(VarNext,bitIndex591) )
            & ( v4933_18__array(VarNext,A,bitIndex18)
            <=> v7444(VarNext,bitIndex590) )
            & ( v4933_18__array(VarNext,A,bitIndex17)
            <=> v7444(VarNext,bitIndex589) )
            & ( v4933_18__array(VarNext,A,bitIndex16)
            <=> v7444(VarNext,bitIndex588) )
            & ( v4933_18__array(VarNext,A,bitIndex15)
            <=> v7444(VarNext,bitIndex587) )
            & ( v4933_18__array(VarNext,A,bitIndex14)
            <=> v7444(VarNext,bitIndex586) )
            & ( v4933_18__array(VarNext,A,bitIndex13)
            <=> v7444(VarNext,bitIndex585) )
            & ( v4933_18__array(VarNext,A,bitIndex12)
            <=> v7444(VarNext,bitIndex584) )
            & ( v4933_18__array(VarNext,A,bitIndex11)
            <=> v7444(VarNext,bitIndex583) )
            & ( v4933_18__array(VarNext,A,bitIndex10)
            <=> v7444(VarNext,bitIndex582) )
            & ( v4933_18__array(VarNext,A,bitIndex9)
            <=> v7444(VarNext,bitIndex581) )
            & ( v4933_18__array(VarNext,A,bitIndex8)
            <=> v7444(VarNext,bitIndex580) )
            & ( v4933_18__array(VarNext,A,bitIndex7)
            <=> v7444(VarNext,bitIndex579) )
            & ( v4933_18__array(VarNext,A,bitIndex6)
            <=> v7444(VarNext,bitIndex578) )
            & ( v4933_18__array(VarNext,A,bitIndex5)
            <=> v7444(VarNext,bitIndex577) )
            & ( v4933_18__array(VarNext,A,bitIndex4)
            <=> v7444(VarNext,bitIndex576) )
            & ( v4933_18__array(VarNext,A,bitIndex3)
            <=> v7444(VarNext,bitIndex575) )
            & ( v4933_18__array(VarNext,A,bitIndex2)
            <=> v7444(VarNext,bitIndex574) )
            & ( v4933_18__array(VarNext,A,bitIndex1)
            <=> v7444(VarNext,bitIndex573) )
            & ( v4933_18__array(VarNext,A,bitIndex0)
            <=> v7444(VarNext,bitIndex572) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1335,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7438(VarNext)
      <=> ( v7439(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1334,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7439(VarNext)
      <=> ( v7441(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_628,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7441(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_36,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01100_address_term = A
              & v7429(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_17__array(VarNext,A,B)
              <=> v4933_16__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_36,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01100_address_term = A
            & v7429(VarNext) )
         => ( ( v4933_17__array(VarNext,A,bitIndex43)
            <=> v7435(VarNext,bitIndex571) )
            & ( v4933_17__array(VarNext,A,bitIndex42)
            <=> v7435(VarNext,bitIndex570) )
            & ( v4933_17__array(VarNext,A,bitIndex41)
            <=> v7435(VarNext,bitIndex569) )
            & ( v4933_17__array(VarNext,A,bitIndex40)
            <=> v7435(VarNext,bitIndex568) )
            & ( v4933_17__array(VarNext,A,bitIndex39)
            <=> v7435(VarNext,bitIndex567) )
            & ( v4933_17__array(VarNext,A,bitIndex38)
            <=> v7435(VarNext,bitIndex566) )
            & ( v4933_17__array(VarNext,A,bitIndex37)
            <=> v7435(VarNext,bitIndex565) )
            & ( v4933_17__array(VarNext,A,bitIndex36)
            <=> v7435(VarNext,bitIndex564) )
            & ( v4933_17__array(VarNext,A,bitIndex35)
            <=> v7435(VarNext,bitIndex563) )
            & ( v4933_17__array(VarNext,A,bitIndex34)
            <=> v7435(VarNext,bitIndex562) )
            & ( v4933_17__array(VarNext,A,bitIndex33)
            <=> v7435(VarNext,bitIndex561) )
            & ( v4933_17__array(VarNext,A,bitIndex32)
            <=> v7435(VarNext,bitIndex560) )
            & ( v4933_17__array(VarNext,A,bitIndex31)
            <=> v7435(VarNext,bitIndex559) )
            & ( v4933_17__array(VarNext,A,bitIndex30)
            <=> v7435(VarNext,bitIndex558) )
            & ( v4933_17__array(VarNext,A,bitIndex29)
            <=> v7435(VarNext,bitIndex557) )
            & ( v4933_17__array(VarNext,A,bitIndex28)
            <=> v7435(VarNext,bitIndex556) )
            & ( v4933_17__array(VarNext,A,bitIndex27)
            <=> v7435(VarNext,bitIndex555) )
            & ( v4933_17__array(VarNext,A,bitIndex26)
            <=> v7435(VarNext,bitIndex554) )
            & ( v4933_17__array(VarNext,A,bitIndex25)
            <=> v7435(VarNext,bitIndex553) )
            & ( v4933_17__array(VarNext,A,bitIndex24)
            <=> v7435(VarNext,bitIndex552) )
            & ( v4933_17__array(VarNext,A,bitIndex23)
            <=> v7435(VarNext,bitIndex551) )
            & ( v4933_17__array(VarNext,A,bitIndex22)
            <=> v7435(VarNext,bitIndex550) )
            & ( v4933_17__array(VarNext,A,bitIndex21)
            <=> v7435(VarNext,bitIndex549) )
            & ( v4933_17__array(VarNext,A,bitIndex20)
            <=> v7435(VarNext,bitIndex548) )
            & ( v4933_17__array(VarNext,A,bitIndex19)
            <=> v7435(VarNext,bitIndex547) )
            & ( v4933_17__array(VarNext,A,bitIndex18)
            <=> v7435(VarNext,bitIndex546) )
            & ( v4933_17__array(VarNext,A,bitIndex17)
            <=> v7435(VarNext,bitIndex545) )
            & ( v4933_17__array(VarNext,A,bitIndex16)
            <=> v7435(VarNext,bitIndex544) )
            & ( v4933_17__array(VarNext,A,bitIndex15)
            <=> v7435(VarNext,bitIndex543) )
            & ( v4933_17__array(VarNext,A,bitIndex14)
            <=> v7435(VarNext,bitIndex542) )
            & ( v4933_17__array(VarNext,A,bitIndex13)
            <=> v7435(VarNext,bitIndex541) )
            & ( v4933_17__array(VarNext,A,bitIndex12)
            <=> v7435(VarNext,bitIndex540) )
            & ( v4933_17__array(VarNext,A,bitIndex11)
            <=> v7435(VarNext,bitIndex539) )
            & ( v4933_17__array(VarNext,A,bitIndex10)
            <=> v7435(VarNext,bitIndex538) )
            & ( v4933_17__array(VarNext,A,bitIndex9)
            <=> v7435(VarNext,bitIndex537) )
            & ( v4933_17__array(VarNext,A,bitIndex8)
            <=> v7435(VarNext,bitIndex536) )
            & ( v4933_17__array(VarNext,A,bitIndex7)
            <=> v7435(VarNext,bitIndex535) )
            & ( v4933_17__array(VarNext,A,bitIndex6)
            <=> v7435(VarNext,bitIndex534) )
            & ( v4933_17__array(VarNext,A,bitIndex5)
            <=> v7435(VarNext,bitIndex533) )
            & ( v4933_17__array(VarNext,A,bitIndex4)
            <=> v7435(VarNext,bitIndex532) )
            & ( v4933_17__array(VarNext,A,bitIndex3)
            <=> v7435(VarNext,bitIndex531) )
            & ( v4933_17__array(VarNext,A,bitIndex2)
            <=> v7435(VarNext,bitIndex530) )
            & ( v4933_17__array(VarNext,A,bitIndex1)
            <=> v7435(VarNext,bitIndex529) )
            & ( v4933_17__array(VarNext,A,bitIndex0)
            <=> v7435(VarNext,bitIndex528) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1333,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7429(VarNext)
      <=> ( v7430(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1332,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7430(VarNext)
      <=> ( v7432(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_627,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7432(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_35,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01011_address_term = A
              & v7420(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_16__array(VarNext,A,B)
              <=> v4933_15__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_35,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01011_address_term = A
            & v7420(VarNext) )
         => ( ( v4933_16__array(VarNext,A,bitIndex43)
            <=> v7426(VarNext,bitIndex527) )
            & ( v4933_16__array(VarNext,A,bitIndex42)
            <=> v7426(VarNext,bitIndex526) )
            & ( v4933_16__array(VarNext,A,bitIndex41)
            <=> v7426(VarNext,bitIndex525) )
            & ( v4933_16__array(VarNext,A,bitIndex40)
            <=> v7426(VarNext,bitIndex524) )
            & ( v4933_16__array(VarNext,A,bitIndex39)
            <=> v7426(VarNext,bitIndex523) )
            & ( v4933_16__array(VarNext,A,bitIndex38)
            <=> v7426(VarNext,bitIndex522) )
            & ( v4933_16__array(VarNext,A,bitIndex37)
            <=> v7426(VarNext,bitIndex521) )
            & ( v4933_16__array(VarNext,A,bitIndex36)
            <=> v7426(VarNext,bitIndex520) )
            & ( v4933_16__array(VarNext,A,bitIndex35)
            <=> v7426(VarNext,bitIndex519) )
            & ( v4933_16__array(VarNext,A,bitIndex34)
            <=> v7426(VarNext,bitIndex518) )
            & ( v4933_16__array(VarNext,A,bitIndex33)
            <=> v7426(VarNext,bitIndex517) )
            & ( v4933_16__array(VarNext,A,bitIndex32)
            <=> v7426(VarNext,bitIndex516) )
            & ( v4933_16__array(VarNext,A,bitIndex31)
            <=> v7426(VarNext,bitIndex515) )
            & ( v4933_16__array(VarNext,A,bitIndex30)
            <=> v7426(VarNext,bitIndex514) )
            & ( v4933_16__array(VarNext,A,bitIndex29)
            <=> v7426(VarNext,bitIndex513) )
            & ( v4933_16__array(VarNext,A,bitIndex28)
            <=> v7426(VarNext,bitIndex512) )
            & ( v4933_16__array(VarNext,A,bitIndex27)
            <=> v7426(VarNext,bitIndex511) )
            & ( v4933_16__array(VarNext,A,bitIndex26)
            <=> v7426(VarNext,bitIndex510) )
            & ( v4933_16__array(VarNext,A,bitIndex25)
            <=> v7426(VarNext,bitIndex509) )
            & ( v4933_16__array(VarNext,A,bitIndex24)
            <=> v7426(VarNext,bitIndex508) )
            & ( v4933_16__array(VarNext,A,bitIndex23)
            <=> v7426(VarNext,bitIndex507) )
            & ( v4933_16__array(VarNext,A,bitIndex22)
            <=> v7426(VarNext,bitIndex506) )
            & ( v4933_16__array(VarNext,A,bitIndex21)
            <=> v7426(VarNext,bitIndex505) )
            & ( v4933_16__array(VarNext,A,bitIndex20)
            <=> v7426(VarNext,bitIndex504) )
            & ( v4933_16__array(VarNext,A,bitIndex19)
            <=> v7426(VarNext,bitIndex503) )
            & ( v4933_16__array(VarNext,A,bitIndex18)
            <=> v7426(VarNext,bitIndex502) )
            & ( v4933_16__array(VarNext,A,bitIndex17)
            <=> v7426(VarNext,bitIndex501) )
            & ( v4933_16__array(VarNext,A,bitIndex16)
            <=> v7426(VarNext,bitIndex500) )
            & ( v4933_16__array(VarNext,A,bitIndex15)
            <=> v7426(VarNext,bitIndex499) )
            & ( v4933_16__array(VarNext,A,bitIndex14)
            <=> v7426(VarNext,bitIndex498) )
            & ( v4933_16__array(VarNext,A,bitIndex13)
            <=> v7426(VarNext,bitIndex497) )
            & ( v4933_16__array(VarNext,A,bitIndex12)
            <=> v7426(VarNext,bitIndex496) )
            & ( v4933_16__array(VarNext,A,bitIndex11)
            <=> v7426(VarNext,bitIndex495) )
            & ( v4933_16__array(VarNext,A,bitIndex10)
            <=> v7426(VarNext,bitIndex494) )
            & ( v4933_16__array(VarNext,A,bitIndex9)
            <=> v7426(VarNext,bitIndex493) )
            & ( v4933_16__array(VarNext,A,bitIndex8)
            <=> v7426(VarNext,bitIndex492) )
            & ( v4933_16__array(VarNext,A,bitIndex7)
            <=> v7426(VarNext,bitIndex491) )
            & ( v4933_16__array(VarNext,A,bitIndex6)
            <=> v7426(VarNext,bitIndex490) )
            & ( v4933_16__array(VarNext,A,bitIndex5)
            <=> v7426(VarNext,bitIndex489) )
            & ( v4933_16__array(VarNext,A,bitIndex4)
            <=> v7426(VarNext,bitIndex488) )
            & ( v4933_16__array(VarNext,A,bitIndex3)
            <=> v7426(VarNext,bitIndex487) )
            & ( v4933_16__array(VarNext,A,bitIndex2)
            <=> v7426(VarNext,bitIndex486) )
            & ( v4933_16__array(VarNext,A,bitIndex1)
            <=> v7426(VarNext,bitIndex485) )
            & ( v4933_16__array(VarNext,A,bitIndex0)
            <=> v7426(VarNext,bitIndex484) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1331,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7420(VarNext)
      <=> ( v7421(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1330,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7421(VarNext)
      <=> ( v7423(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_626,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7423(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_34,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01010_address_term = A
              & v7411(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_15__array(VarNext,A,B)
              <=> v4933_14__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_34,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01010_address_term = A
            & v7411(VarNext) )
         => ( ( v4933_15__array(VarNext,A,bitIndex43)
            <=> v7417(VarNext,bitIndex483) )
            & ( v4933_15__array(VarNext,A,bitIndex42)
            <=> v7417(VarNext,bitIndex482) )
            & ( v4933_15__array(VarNext,A,bitIndex41)
            <=> v7417(VarNext,bitIndex481) )
            & ( v4933_15__array(VarNext,A,bitIndex40)
            <=> v7417(VarNext,bitIndex480) )
            & ( v4933_15__array(VarNext,A,bitIndex39)
            <=> v7417(VarNext,bitIndex479) )
            & ( v4933_15__array(VarNext,A,bitIndex38)
            <=> v7417(VarNext,bitIndex478) )
            & ( v4933_15__array(VarNext,A,bitIndex37)
            <=> v7417(VarNext,bitIndex477) )
            & ( v4933_15__array(VarNext,A,bitIndex36)
            <=> v7417(VarNext,bitIndex476) )
            & ( v4933_15__array(VarNext,A,bitIndex35)
            <=> v7417(VarNext,bitIndex475) )
            & ( v4933_15__array(VarNext,A,bitIndex34)
            <=> v7417(VarNext,bitIndex474) )
            & ( v4933_15__array(VarNext,A,bitIndex33)
            <=> v7417(VarNext,bitIndex473) )
            & ( v4933_15__array(VarNext,A,bitIndex32)
            <=> v7417(VarNext,bitIndex472) )
            & ( v4933_15__array(VarNext,A,bitIndex31)
            <=> v7417(VarNext,bitIndex471) )
            & ( v4933_15__array(VarNext,A,bitIndex30)
            <=> v7417(VarNext,bitIndex470) )
            & ( v4933_15__array(VarNext,A,bitIndex29)
            <=> v7417(VarNext,bitIndex469) )
            & ( v4933_15__array(VarNext,A,bitIndex28)
            <=> v7417(VarNext,bitIndex468) )
            & ( v4933_15__array(VarNext,A,bitIndex27)
            <=> v7417(VarNext,bitIndex467) )
            & ( v4933_15__array(VarNext,A,bitIndex26)
            <=> v7417(VarNext,bitIndex466) )
            & ( v4933_15__array(VarNext,A,bitIndex25)
            <=> v7417(VarNext,bitIndex465) )
            & ( v4933_15__array(VarNext,A,bitIndex24)
            <=> v7417(VarNext,bitIndex464) )
            & ( v4933_15__array(VarNext,A,bitIndex23)
            <=> v7417(VarNext,bitIndex463) )
            & ( v4933_15__array(VarNext,A,bitIndex22)
            <=> v7417(VarNext,bitIndex462) )
            & ( v4933_15__array(VarNext,A,bitIndex21)
            <=> v7417(VarNext,bitIndex461) )
            & ( v4933_15__array(VarNext,A,bitIndex20)
            <=> v7417(VarNext,bitIndex460) )
            & ( v4933_15__array(VarNext,A,bitIndex19)
            <=> v7417(VarNext,bitIndex459) )
            & ( v4933_15__array(VarNext,A,bitIndex18)
            <=> v7417(VarNext,bitIndex458) )
            & ( v4933_15__array(VarNext,A,bitIndex17)
            <=> v7417(VarNext,bitIndex457) )
            & ( v4933_15__array(VarNext,A,bitIndex16)
            <=> v7417(VarNext,bitIndex456) )
            & ( v4933_15__array(VarNext,A,bitIndex15)
            <=> v7417(VarNext,bitIndex455) )
            & ( v4933_15__array(VarNext,A,bitIndex14)
            <=> v7417(VarNext,bitIndex454) )
            & ( v4933_15__array(VarNext,A,bitIndex13)
            <=> v7417(VarNext,bitIndex453) )
            & ( v4933_15__array(VarNext,A,bitIndex12)
            <=> v7417(VarNext,bitIndex452) )
            & ( v4933_15__array(VarNext,A,bitIndex11)
            <=> v7417(VarNext,bitIndex451) )
            & ( v4933_15__array(VarNext,A,bitIndex10)
            <=> v7417(VarNext,bitIndex450) )
            & ( v4933_15__array(VarNext,A,bitIndex9)
            <=> v7417(VarNext,bitIndex449) )
            & ( v4933_15__array(VarNext,A,bitIndex8)
            <=> v7417(VarNext,bitIndex448) )
            & ( v4933_15__array(VarNext,A,bitIndex7)
            <=> v7417(VarNext,bitIndex447) )
            & ( v4933_15__array(VarNext,A,bitIndex6)
            <=> v7417(VarNext,bitIndex446) )
            & ( v4933_15__array(VarNext,A,bitIndex5)
            <=> v7417(VarNext,bitIndex445) )
            & ( v4933_15__array(VarNext,A,bitIndex4)
            <=> v7417(VarNext,bitIndex444) )
            & ( v4933_15__array(VarNext,A,bitIndex3)
            <=> v7417(VarNext,bitIndex443) )
            & ( v4933_15__array(VarNext,A,bitIndex2)
            <=> v7417(VarNext,bitIndex442) )
            & ( v4933_15__array(VarNext,A,bitIndex1)
            <=> v7417(VarNext,bitIndex441) )
            & ( v4933_15__array(VarNext,A,bitIndex0)
            <=> v7417(VarNext,bitIndex440) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1329,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7411(VarNext)
      <=> ( v7412(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1328,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7412(VarNext)
      <=> ( v7414(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_625,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7414(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_33,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01001_address_term = A
              & v7402(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_14__array(VarNext,A,B)
              <=> v4933_13__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_33,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01001_address_term = A
            & v7402(VarNext) )
         => ( ( v4933_14__array(VarNext,A,bitIndex43)
            <=> v7408(VarNext,bitIndex439) )
            & ( v4933_14__array(VarNext,A,bitIndex42)
            <=> v7408(VarNext,bitIndex438) )
            & ( v4933_14__array(VarNext,A,bitIndex41)
            <=> v7408(VarNext,bitIndex437) )
            & ( v4933_14__array(VarNext,A,bitIndex40)
            <=> v7408(VarNext,bitIndex436) )
            & ( v4933_14__array(VarNext,A,bitIndex39)
            <=> v7408(VarNext,bitIndex435) )
            & ( v4933_14__array(VarNext,A,bitIndex38)
            <=> v7408(VarNext,bitIndex434) )
            & ( v4933_14__array(VarNext,A,bitIndex37)
            <=> v7408(VarNext,bitIndex433) )
            & ( v4933_14__array(VarNext,A,bitIndex36)
            <=> v7408(VarNext,bitIndex432) )
            & ( v4933_14__array(VarNext,A,bitIndex35)
            <=> v7408(VarNext,bitIndex431) )
            & ( v4933_14__array(VarNext,A,bitIndex34)
            <=> v7408(VarNext,bitIndex430) )
            & ( v4933_14__array(VarNext,A,bitIndex33)
            <=> v7408(VarNext,bitIndex429) )
            & ( v4933_14__array(VarNext,A,bitIndex32)
            <=> v7408(VarNext,bitIndex428) )
            & ( v4933_14__array(VarNext,A,bitIndex31)
            <=> v7408(VarNext,bitIndex427) )
            & ( v4933_14__array(VarNext,A,bitIndex30)
            <=> v7408(VarNext,bitIndex426) )
            & ( v4933_14__array(VarNext,A,bitIndex29)
            <=> v7408(VarNext,bitIndex425) )
            & ( v4933_14__array(VarNext,A,bitIndex28)
            <=> v7408(VarNext,bitIndex424) )
            & ( v4933_14__array(VarNext,A,bitIndex27)
            <=> v7408(VarNext,bitIndex423) )
            & ( v4933_14__array(VarNext,A,bitIndex26)
            <=> v7408(VarNext,bitIndex422) )
            & ( v4933_14__array(VarNext,A,bitIndex25)
            <=> v7408(VarNext,bitIndex421) )
            & ( v4933_14__array(VarNext,A,bitIndex24)
            <=> v7408(VarNext,bitIndex420) )
            & ( v4933_14__array(VarNext,A,bitIndex23)
            <=> v7408(VarNext,bitIndex419) )
            & ( v4933_14__array(VarNext,A,bitIndex22)
            <=> v7408(VarNext,bitIndex418) )
            & ( v4933_14__array(VarNext,A,bitIndex21)
            <=> v7408(VarNext,bitIndex417) )
            & ( v4933_14__array(VarNext,A,bitIndex20)
            <=> v7408(VarNext,bitIndex416) )
            & ( v4933_14__array(VarNext,A,bitIndex19)
            <=> v7408(VarNext,bitIndex415) )
            & ( v4933_14__array(VarNext,A,bitIndex18)
            <=> v7408(VarNext,bitIndex414) )
            & ( v4933_14__array(VarNext,A,bitIndex17)
            <=> v7408(VarNext,bitIndex413) )
            & ( v4933_14__array(VarNext,A,bitIndex16)
            <=> v7408(VarNext,bitIndex412) )
            & ( v4933_14__array(VarNext,A,bitIndex15)
            <=> v7408(VarNext,bitIndex411) )
            & ( v4933_14__array(VarNext,A,bitIndex14)
            <=> v7408(VarNext,bitIndex410) )
            & ( v4933_14__array(VarNext,A,bitIndex13)
            <=> v7408(VarNext,bitIndex409) )
            & ( v4933_14__array(VarNext,A,bitIndex12)
            <=> v7408(VarNext,bitIndex408) )
            & ( v4933_14__array(VarNext,A,bitIndex11)
            <=> v7408(VarNext,bitIndex407) )
            & ( v4933_14__array(VarNext,A,bitIndex10)
            <=> v7408(VarNext,bitIndex406) )
            & ( v4933_14__array(VarNext,A,bitIndex9)
            <=> v7408(VarNext,bitIndex405) )
            & ( v4933_14__array(VarNext,A,bitIndex8)
            <=> v7408(VarNext,bitIndex404) )
            & ( v4933_14__array(VarNext,A,bitIndex7)
            <=> v7408(VarNext,bitIndex403) )
            & ( v4933_14__array(VarNext,A,bitIndex6)
            <=> v7408(VarNext,bitIndex402) )
            & ( v4933_14__array(VarNext,A,bitIndex5)
            <=> v7408(VarNext,bitIndex401) )
            & ( v4933_14__array(VarNext,A,bitIndex4)
            <=> v7408(VarNext,bitIndex400) )
            & ( v4933_14__array(VarNext,A,bitIndex3)
            <=> v7408(VarNext,bitIndex399) )
            & ( v4933_14__array(VarNext,A,bitIndex2)
            <=> v7408(VarNext,bitIndex398) )
            & ( v4933_14__array(VarNext,A,bitIndex1)
            <=> v7408(VarNext,bitIndex397) )
            & ( v4933_14__array(VarNext,A,bitIndex0)
            <=> v7408(VarNext,bitIndex396) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1327,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7402(VarNext)
      <=> ( v7403(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1326,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7403(VarNext)
      <=> ( v7405(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_624,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7405(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_32,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b01000_address_term = A
              & v7393(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_13__array(VarNext,A,B)
              <=> v4933_12__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_32,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b01000_address_term = A
            & v7393(VarNext) )
         => ( ( v4933_13__array(VarNext,A,bitIndex43)
            <=> v7399(VarNext,bitIndex395) )
            & ( v4933_13__array(VarNext,A,bitIndex42)
            <=> v7399(VarNext,bitIndex394) )
            & ( v4933_13__array(VarNext,A,bitIndex41)
            <=> v7399(VarNext,bitIndex393) )
            & ( v4933_13__array(VarNext,A,bitIndex40)
            <=> v7399(VarNext,bitIndex392) )
            & ( v4933_13__array(VarNext,A,bitIndex39)
            <=> v7399(VarNext,bitIndex391) )
            & ( v4933_13__array(VarNext,A,bitIndex38)
            <=> v7399(VarNext,bitIndex390) )
            & ( v4933_13__array(VarNext,A,bitIndex37)
            <=> v7399(VarNext,bitIndex389) )
            & ( v4933_13__array(VarNext,A,bitIndex36)
            <=> v7399(VarNext,bitIndex388) )
            & ( v4933_13__array(VarNext,A,bitIndex35)
            <=> v7399(VarNext,bitIndex387) )
            & ( v4933_13__array(VarNext,A,bitIndex34)
            <=> v7399(VarNext,bitIndex386) )
            & ( v4933_13__array(VarNext,A,bitIndex33)
            <=> v7399(VarNext,bitIndex385) )
            & ( v4933_13__array(VarNext,A,bitIndex32)
            <=> v7399(VarNext,bitIndex384) )
            & ( v4933_13__array(VarNext,A,bitIndex31)
            <=> v7399(VarNext,bitIndex383) )
            & ( v4933_13__array(VarNext,A,bitIndex30)
            <=> v7399(VarNext,bitIndex382) )
            & ( v4933_13__array(VarNext,A,bitIndex29)
            <=> v7399(VarNext,bitIndex381) )
            & ( v4933_13__array(VarNext,A,bitIndex28)
            <=> v7399(VarNext,bitIndex380) )
            & ( v4933_13__array(VarNext,A,bitIndex27)
            <=> v7399(VarNext,bitIndex379) )
            & ( v4933_13__array(VarNext,A,bitIndex26)
            <=> v7399(VarNext,bitIndex378) )
            & ( v4933_13__array(VarNext,A,bitIndex25)
            <=> v7399(VarNext,bitIndex377) )
            & ( v4933_13__array(VarNext,A,bitIndex24)
            <=> v7399(VarNext,bitIndex376) )
            & ( v4933_13__array(VarNext,A,bitIndex23)
            <=> v7399(VarNext,bitIndex375) )
            & ( v4933_13__array(VarNext,A,bitIndex22)
            <=> v7399(VarNext,bitIndex374) )
            & ( v4933_13__array(VarNext,A,bitIndex21)
            <=> v7399(VarNext,bitIndex373) )
            & ( v4933_13__array(VarNext,A,bitIndex20)
            <=> v7399(VarNext,bitIndex372) )
            & ( v4933_13__array(VarNext,A,bitIndex19)
            <=> v7399(VarNext,bitIndex371) )
            & ( v4933_13__array(VarNext,A,bitIndex18)
            <=> v7399(VarNext,bitIndex370) )
            & ( v4933_13__array(VarNext,A,bitIndex17)
            <=> v7399(VarNext,bitIndex369) )
            & ( v4933_13__array(VarNext,A,bitIndex16)
            <=> v7399(VarNext,bitIndex368) )
            & ( v4933_13__array(VarNext,A,bitIndex15)
            <=> v7399(VarNext,bitIndex367) )
            & ( v4933_13__array(VarNext,A,bitIndex14)
            <=> v7399(VarNext,bitIndex366) )
            & ( v4933_13__array(VarNext,A,bitIndex13)
            <=> v7399(VarNext,bitIndex365) )
            & ( v4933_13__array(VarNext,A,bitIndex12)
            <=> v7399(VarNext,bitIndex364) )
            & ( v4933_13__array(VarNext,A,bitIndex11)
            <=> v7399(VarNext,bitIndex363) )
            & ( v4933_13__array(VarNext,A,bitIndex10)
            <=> v7399(VarNext,bitIndex362) )
            & ( v4933_13__array(VarNext,A,bitIndex9)
            <=> v7399(VarNext,bitIndex361) )
            & ( v4933_13__array(VarNext,A,bitIndex8)
            <=> v7399(VarNext,bitIndex360) )
            & ( v4933_13__array(VarNext,A,bitIndex7)
            <=> v7399(VarNext,bitIndex359) )
            & ( v4933_13__array(VarNext,A,bitIndex6)
            <=> v7399(VarNext,bitIndex358) )
            & ( v4933_13__array(VarNext,A,bitIndex5)
            <=> v7399(VarNext,bitIndex357) )
            & ( v4933_13__array(VarNext,A,bitIndex4)
            <=> v7399(VarNext,bitIndex356) )
            & ( v4933_13__array(VarNext,A,bitIndex3)
            <=> v7399(VarNext,bitIndex355) )
            & ( v4933_13__array(VarNext,A,bitIndex2)
            <=> v7399(VarNext,bitIndex354) )
            & ( v4933_13__array(VarNext,A,bitIndex1)
            <=> v7399(VarNext,bitIndex353) )
            & ( v4933_13__array(VarNext,A,bitIndex0)
            <=> v7399(VarNext,bitIndex352) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1325,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7393(VarNext)
      <=> ( v7394(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1324,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7394(VarNext)
      <=> ( v7396(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_623,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7396(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_31,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00111_address_term = A
              & v7384(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_12__array(VarNext,A,B)
              <=> v4933_11__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_31,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00111_address_term = A
            & v7384(VarNext) )
         => ( ( v4933_12__array(VarNext,A,bitIndex43)
            <=> v7390(VarNext,bitIndex351) )
            & ( v4933_12__array(VarNext,A,bitIndex42)
            <=> v7390(VarNext,bitIndex350) )
            & ( v4933_12__array(VarNext,A,bitIndex41)
            <=> v7390(VarNext,bitIndex349) )
            & ( v4933_12__array(VarNext,A,bitIndex40)
            <=> v7390(VarNext,bitIndex348) )
            & ( v4933_12__array(VarNext,A,bitIndex39)
            <=> v7390(VarNext,bitIndex347) )
            & ( v4933_12__array(VarNext,A,bitIndex38)
            <=> v7390(VarNext,bitIndex346) )
            & ( v4933_12__array(VarNext,A,bitIndex37)
            <=> v7390(VarNext,bitIndex345) )
            & ( v4933_12__array(VarNext,A,bitIndex36)
            <=> v7390(VarNext,bitIndex344) )
            & ( v4933_12__array(VarNext,A,bitIndex35)
            <=> v7390(VarNext,bitIndex343) )
            & ( v4933_12__array(VarNext,A,bitIndex34)
            <=> v7390(VarNext,bitIndex342) )
            & ( v4933_12__array(VarNext,A,bitIndex33)
            <=> v7390(VarNext,bitIndex341) )
            & ( v4933_12__array(VarNext,A,bitIndex32)
            <=> v7390(VarNext,bitIndex340) )
            & ( v4933_12__array(VarNext,A,bitIndex31)
            <=> v7390(VarNext,bitIndex339) )
            & ( v4933_12__array(VarNext,A,bitIndex30)
            <=> v7390(VarNext,bitIndex338) )
            & ( v4933_12__array(VarNext,A,bitIndex29)
            <=> v7390(VarNext,bitIndex337) )
            & ( v4933_12__array(VarNext,A,bitIndex28)
            <=> v7390(VarNext,bitIndex336) )
            & ( v4933_12__array(VarNext,A,bitIndex27)
            <=> v7390(VarNext,bitIndex335) )
            & ( v4933_12__array(VarNext,A,bitIndex26)
            <=> v7390(VarNext,bitIndex334) )
            & ( v4933_12__array(VarNext,A,bitIndex25)
            <=> v7390(VarNext,bitIndex333) )
            & ( v4933_12__array(VarNext,A,bitIndex24)
            <=> v7390(VarNext,bitIndex332) )
            & ( v4933_12__array(VarNext,A,bitIndex23)
            <=> v7390(VarNext,bitIndex331) )
            & ( v4933_12__array(VarNext,A,bitIndex22)
            <=> v7390(VarNext,bitIndex330) )
            & ( v4933_12__array(VarNext,A,bitIndex21)
            <=> v7390(VarNext,bitIndex329) )
            & ( v4933_12__array(VarNext,A,bitIndex20)
            <=> v7390(VarNext,bitIndex328) )
            & ( v4933_12__array(VarNext,A,bitIndex19)
            <=> v7390(VarNext,bitIndex327) )
            & ( v4933_12__array(VarNext,A,bitIndex18)
            <=> v7390(VarNext,bitIndex326) )
            & ( v4933_12__array(VarNext,A,bitIndex17)
            <=> v7390(VarNext,bitIndex325) )
            & ( v4933_12__array(VarNext,A,bitIndex16)
            <=> v7390(VarNext,bitIndex324) )
            & ( v4933_12__array(VarNext,A,bitIndex15)
            <=> v7390(VarNext,bitIndex323) )
            & ( v4933_12__array(VarNext,A,bitIndex14)
            <=> v7390(VarNext,bitIndex322) )
            & ( v4933_12__array(VarNext,A,bitIndex13)
            <=> v7390(VarNext,bitIndex321) )
            & ( v4933_12__array(VarNext,A,bitIndex12)
            <=> v7390(VarNext,bitIndex320) )
            & ( v4933_12__array(VarNext,A,bitIndex11)
            <=> v7390(VarNext,bitIndex319) )
            & ( v4933_12__array(VarNext,A,bitIndex10)
            <=> v7390(VarNext,bitIndex318) )
            & ( v4933_12__array(VarNext,A,bitIndex9)
            <=> v7390(VarNext,bitIndex317) )
            & ( v4933_12__array(VarNext,A,bitIndex8)
            <=> v7390(VarNext,bitIndex316) )
            & ( v4933_12__array(VarNext,A,bitIndex7)
            <=> v7390(VarNext,bitIndex315) )
            & ( v4933_12__array(VarNext,A,bitIndex6)
            <=> v7390(VarNext,bitIndex314) )
            & ( v4933_12__array(VarNext,A,bitIndex5)
            <=> v7390(VarNext,bitIndex313) )
            & ( v4933_12__array(VarNext,A,bitIndex4)
            <=> v7390(VarNext,bitIndex312) )
            & ( v4933_12__array(VarNext,A,bitIndex3)
            <=> v7390(VarNext,bitIndex311) )
            & ( v4933_12__array(VarNext,A,bitIndex2)
            <=> v7390(VarNext,bitIndex310) )
            & ( v4933_12__array(VarNext,A,bitIndex1)
            <=> v7390(VarNext,bitIndex309) )
            & ( v4933_12__array(VarNext,A,bitIndex0)
            <=> v7390(VarNext,bitIndex308) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1323,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7384(VarNext)
      <=> ( v7385(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1322,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7385(VarNext)
      <=> ( v7387(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_622,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7387(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_30,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00110_address_term = A
              & v7375(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_11__array(VarNext,A,B)
              <=> v4933_10__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_30,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00110_address_term = A
            & v7375(VarNext) )
         => ( ( v4933_11__array(VarNext,A,bitIndex43)
            <=> v7381(VarNext,bitIndex307) )
            & ( v4933_11__array(VarNext,A,bitIndex42)
            <=> v7381(VarNext,bitIndex306) )
            & ( v4933_11__array(VarNext,A,bitIndex41)
            <=> v7381(VarNext,bitIndex305) )
            & ( v4933_11__array(VarNext,A,bitIndex40)
            <=> v7381(VarNext,bitIndex304) )
            & ( v4933_11__array(VarNext,A,bitIndex39)
            <=> v7381(VarNext,bitIndex303) )
            & ( v4933_11__array(VarNext,A,bitIndex38)
            <=> v7381(VarNext,bitIndex302) )
            & ( v4933_11__array(VarNext,A,bitIndex37)
            <=> v7381(VarNext,bitIndex301) )
            & ( v4933_11__array(VarNext,A,bitIndex36)
            <=> v7381(VarNext,bitIndex300) )
            & ( v4933_11__array(VarNext,A,bitIndex35)
            <=> v7381(VarNext,bitIndex299) )
            & ( v4933_11__array(VarNext,A,bitIndex34)
            <=> v7381(VarNext,bitIndex298) )
            & ( v4933_11__array(VarNext,A,bitIndex33)
            <=> v7381(VarNext,bitIndex297) )
            & ( v4933_11__array(VarNext,A,bitIndex32)
            <=> v7381(VarNext,bitIndex296) )
            & ( v4933_11__array(VarNext,A,bitIndex31)
            <=> v7381(VarNext,bitIndex295) )
            & ( v4933_11__array(VarNext,A,bitIndex30)
            <=> v7381(VarNext,bitIndex294) )
            & ( v4933_11__array(VarNext,A,bitIndex29)
            <=> v7381(VarNext,bitIndex293) )
            & ( v4933_11__array(VarNext,A,bitIndex28)
            <=> v7381(VarNext,bitIndex292) )
            & ( v4933_11__array(VarNext,A,bitIndex27)
            <=> v7381(VarNext,bitIndex291) )
            & ( v4933_11__array(VarNext,A,bitIndex26)
            <=> v7381(VarNext,bitIndex290) )
            & ( v4933_11__array(VarNext,A,bitIndex25)
            <=> v7381(VarNext,bitIndex289) )
            & ( v4933_11__array(VarNext,A,bitIndex24)
            <=> v7381(VarNext,bitIndex288) )
            & ( v4933_11__array(VarNext,A,bitIndex23)
            <=> v7381(VarNext,bitIndex287) )
            & ( v4933_11__array(VarNext,A,bitIndex22)
            <=> v7381(VarNext,bitIndex286) )
            & ( v4933_11__array(VarNext,A,bitIndex21)
            <=> v7381(VarNext,bitIndex285) )
            & ( v4933_11__array(VarNext,A,bitIndex20)
            <=> v7381(VarNext,bitIndex284) )
            & ( v4933_11__array(VarNext,A,bitIndex19)
            <=> v7381(VarNext,bitIndex283) )
            & ( v4933_11__array(VarNext,A,bitIndex18)
            <=> v7381(VarNext,bitIndex282) )
            & ( v4933_11__array(VarNext,A,bitIndex17)
            <=> v7381(VarNext,bitIndex281) )
            & ( v4933_11__array(VarNext,A,bitIndex16)
            <=> v7381(VarNext,bitIndex280) )
            & ( v4933_11__array(VarNext,A,bitIndex15)
            <=> v7381(VarNext,bitIndex279) )
            & ( v4933_11__array(VarNext,A,bitIndex14)
            <=> v7381(VarNext,bitIndex278) )
            & ( v4933_11__array(VarNext,A,bitIndex13)
            <=> v7381(VarNext,bitIndex277) )
            & ( v4933_11__array(VarNext,A,bitIndex12)
            <=> v7381(VarNext,bitIndex276) )
            & ( v4933_11__array(VarNext,A,bitIndex11)
            <=> v7381(VarNext,bitIndex275) )
            & ( v4933_11__array(VarNext,A,bitIndex10)
            <=> v7381(VarNext,bitIndex274) )
            & ( v4933_11__array(VarNext,A,bitIndex9)
            <=> v7381(VarNext,bitIndex273) )
            & ( v4933_11__array(VarNext,A,bitIndex8)
            <=> v7381(VarNext,bitIndex272) )
            & ( v4933_11__array(VarNext,A,bitIndex7)
            <=> v7381(VarNext,bitIndex271) )
            & ( v4933_11__array(VarNext,A,bitIndex6)
            <=> v7381(VarNext,bitIndex270) )
            & ( v4933_11__array(VarNext,A,bitIndex5)
            <=> v7381(VarNext,bitIndex269) )
            & ( v4933_11__array(VarNext,A,bitIndex4)
            <=> v7381(VarNext,bitIndex268) )
            & ( v4933_11__array(VarNext,A,bitIndex3)
            <=> v7381(VarNext,bitIndex267) )
            & ( v4933_11__array(VarNext,A,bitIndex2)
            <=> v7381(VarNext,bitIndex266) )
            & ( v4933_11__array(VarNext,A,bitIndex1)
            <=> v7381(VarNext,bitIndex265) )
            & ( v4933_11__array(VarNext,A,bitIndex0)
            <=> v7381(VarNext,bitIndex264) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1321,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7375(VarNext)
      <=> ( v7376(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1320,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7376(VarNext)
      <=> ( v7378(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_621,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7378(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_29,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00101_address_term = A
              & v7366(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_10__array(VarNext,A,B)
              <=> v4933_9__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_29,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00101_address_term = A
            & v7366(VarNext) )
         => ( ( v4933_10__array(VarNext,A,bitIndex43)
            <=> v7372(VarNext,bitIndex263) )
            & ( v4933_10__array(VarNext,A,bitIndex42)
            <=> v7372(VarNext,bitIndex262) )
            & ( v4933_10__array(VarNext,A,bitIndex41)
            <=> v7372(VarNext,bitIndex261) )
            & ( v4933_10__array(VarNext,A,bitIndex40)
            <=> v7372(VarNext,bitIndex260) )
            & ( v4933_10__array(VarNext,A,bitIndex39)
            <=> v7372(VarNext,bitIndex259) )
            & ( v4933_10__array(VarNext,A,bitIndex38)
            <=> v7372(VarNext,bitIndex258) )
            & ( v4933_10__array(VarNext,A,bitIndex37)
            <=> v7372(VarNext,bitIndex257) )
            & ( v4933_10__array(VarNext,A,bitIndex36)
            <=> v7372(VarNext,bitIndex256) )
            & ( v4933_10__array(VarNext,A,bitIndex35)
            <=> v7372(VarNext,bitIndex255) )
            & ( v4933_10__array(VarNext,A,bitIndex34)
            <=> v7372(VarNext,bitIndex254) )
            & ( v4933_10__array(VarNext,A,bitIndex33)
            <=> v7372(VarNext,bitIndex253) )
            & ( v4933_10__array(VarNext,A,bitIndex32)
            <=> v7372(VarNext,bitIndex252) )
            & ( v4933_10__array(VarNext,A,bitIndex31)
            <=> v7372(VarNext,bitIndex251) )
            & ( v4933_10__array(VarNext,A,bitIndex30)
            <=> v7372(VarNext,bitIndex250) )
            & ( v4933_10__array(VarNext,A,bitIndex29)
            <=> v7372(VarNext,bitIndex249) )
            & ( v4933_10__array(VarNext,A,bitIndex28)
            <=> v7372(VarNext,bitIndex248) )
            & ( v4933_10__array(VarNext,A,bitIndex27)
            <=> v7372(VarNext,bitIndex247) )
            & ( v4933_10__array(VarNext,A,bitIndex26)
            <=> v7372(VarNext,bitIndex246) )
            & ( v4933_10__array(VarNext,A,bitIndex25)
            <=> v7372(VarNext,bitIndex245) )
            & ( v4933_10__array(VarNext,A,bitIndex24)
            <=> v7372(VarNext,bitIndex244) )
            & ( v4933_10__array(VarNext,A,bitIndex23)
            <=> v7372(VarNext,bitIndex243) )
            & ( v4933_10__array(VarNext,A,bitIndex22)
            <=> v7372(VarNext,bitIndex242) )
            & ( v4933_10__array(VarNext,A,bitIndex21)
            <=> v7372(VarNext,bitIndex241) )
            & ( v4933_10__array(VarNext,A,bitIndex20)
            <=> v7372(VarNext,bitIndex240) )
            & ( v4933_10__array(VarNext,A,bitIndex19)
            <=> v7372(VarNext,bitIndex239) )
            & ( v4933_10__array(VarNext,A,bitIndex18)
            <=> v7372(VarNext,bitIndex238) )
            & ( v4933_10__array(VarNext,A,bitIndex17)
            <=> v7372(VarNext,bitIndex237) )
            & ( v4933_10__array(VarNext,A,bitIndex16)
            <=> v7372(VarNext,bitIndex236) )
            & ( v4933_10__array(VarNext,A,bitIndex15)
            <=> v7372(VarNext,bitIndex235) )
            & ( v4933_10__array(VarNext,A,bitIndex14)
            <=> v7372(VarNext,bitIndex234) )
            & ( v4933_10__array(VarNext,A,bitIndex13)
            <=> v7372(VarNext,bitIndex233) )
            & ( v4933_10__array(VarNext,A,bitIndex12)
            <=> v7372(VarNext,bitIndex232) )
            & ( v4933_10__array(VarNext,A,bitIndex11)
            <=> v7372(VarNext,bitIndex231) )
            & ( v4933_10__array(VarNext,A,bitIndex10)
            <=> v7372(VarNext,bitIndex230) )
            & ( v4933_10__array(VarNext,A,bitIndex9)
            <=> v7372(VarNext,bitIndex229) )
            & ( v4933_10__array(VarNext,A,bitIndex8)
            <=> v7372(VarNext,bitIndex228) )
            & ( v4933_10__array(VarNext,A,bitIndex7)
            <=> v7372(VarNext,bitIndex227) )
            & ( v4933_10__array(VarNext,A,bitIndex6)
            <=> v7372(VarNext,bitIndex226) )
            & ( v4933_10__array(VarNext,A,bitIndex5)
            <=> v7372(VarNext,bitIndex225) )
            & ( v4933_10__array(VarNext,A,bitIndex4)
            <=> v7372(VarNext,bitIndex224) )
            & ( v4933_10__array(VarNext,A,bitIndex3)
            <=> v7372(VarNext,bitIndex223) )
            & ( v4933_10__array(VarNext,A,bitIndex2)
            <=> v7372(VarNext,bitIndex222) )
            & ( v4933_10__array(VarNext,A,bitIndex1)
            <=> v7372(VarNext,bitIndex221) )
            & ( v4933_10__array(VarNext,A,bitIndex0)
            <=> v7372(VarNext,bitIndex220) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1319,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7366(VarNext)
      <=> ( v7367(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1318,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7367(VarNext)
      <=> ( v7369(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_620,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7369(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_28,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00100_address_term = A
              & v7357(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_9__array(VarNext,A,B)
              <=> v4933_8__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_28,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00100_address_term = A
            & v7357(VarNext) )
         => ( ( v4933_9__array(VarNext,A,bitIndex43)
            <=> v7363(VarNext,bitIndex219) )
            & ( v4933_9__array(VarNext,A,bitIndex42)
            <=> v7363(VarNext,bitIndex218) )
            & ( v4933_9__array(VarNext,A,bitIndex41)
            <=> v7363(VarNext,bitIndex217) )
            & ( v4933_9__array(VarNext,A,bitIndex40)
            <=> v7363(VarNext,bitIndex216) )
            & ( v4933_9__array(VarNext,A,bitIndex39)
            <=> v7363(VarNext,bitIndex215) )
            & ( v4933_9__array(VarNext,A,bitIndex38)
            <=> v7363(VarNext,bitIndex214) )
            & ( v4933_9__array(VarNext,A,bitIndex37)
            <=> v7363(VarNext,bitIndex213) )
            & ( v4933_9__array(VarNext,A,bitIndex36)
            <=> v7363(VarNext,bitIndex212) )
            & ( v4933_9__array(VarNext,A,bitIndex35)
            <=> v7363(VarNext,bitIndex211) )
            & ( v4933_9__array(VarNext,A,bitIndex34)
            <=> v7363(VarNext,bitIndex210) )
            & ( v4933_9__array(VarNext,A,bitIndex33)
            <=> v7363(VarNext,bitIndex209) )
            & ( v4933_9__array(VarNext,A,bitIndex32)
            <=> v7363(VarNext,bitIndex208) )
            & ( v4933_9__array(VarNext,A,bitIndex31)
            <=> v7363(VarNext,bitIndex207) )
            & ( v4933_9__array(VarNext,A,bitIndex30)
            <=> v7363(VarNext,bitIndex206) )
            & ( v4933_9__array(VarNext,A,bitIndex29)
            <=> v7363(VarNext,bitIndex205) )
            & ( v4933_9__array(VarNext,A,bitIndex28)
            <=> v7363(VarNext,bitIndex204) )
            & ( v4933_9__array(VarNext,A,bitIndex27)
            <=> v7363(VarNext,bitIndex203) )
            & ( v4933_9__array(VarNext,A,bitIndex26)
            <=> v7363(VarNext,bitIndex202) )
            & ( v4933_9__array(VarNext,A,bitIndex25)
            <=> v7363(VarNext,bitIndex201) )
            & ( v4933_9__array(VarNext,A,bitIndex24)
            <=> v7363(VarNext,bitIndex200) )
            & ( v4933_9__array(VarNext,A,bitIndex23)
            <=> v7363(VarNext,bitIndex199) )
            & ( v4933_9__array(VarNext,A,bitIndex22)
            <=> v7363(VarNext,bitIndex198) )
            & ( v4933_9__array(VarNext,A,bitIndex21)
            <=> v7363(VarNext,bitIndex197) )
            & ( v4933_9__array(VarNext,A,bitIndex20)
            <=> v7363(VarNext,bitIndex196) )
            & ( v4933_9__array(VarNext,A,bitIndex19)
            <=> v7363(VarNext,bitIndex195) )
            & ( v4933_9__array(VarNext,A,bitIndex18)
            <=> v7363(VarNext,bitIndex194) )
            & ( v4933_9__array(VarNext,A,bitIndex17)
            <=> v7363(VarNext,bitIndex193) )
            & ( v4933_9__array(VarNext,A,bitIndex16)
            <=> v7363(VarNext,bitIndex192) )
            & ( v4933_9__array(VarNext,A,bitIndex15)
            <=> v7363(VarNext,bitIndex191) )
            & ( v4933_9__array(VarNext,A,bitIndex14)
            <=> v7363(VarNext,bitIndex190) )
            & ( v4933_9__array(VarNext,A,bitIndex13)
            <=> v7363(VarNext,bitIndex189) )
            & ( v4933_9__array(VarNext,A,bitIndex12)
            <=> v7363(VarNext,bitIndex188) )
            & ( v4933_9__array(VarNext,A,bitIndex11)
            <=> v7363(VarNext,bitIndex187) )
            & ( v4933_9__array(VarNext,A,bitIndex10)
            <=> v7363(VarNext,bitIndex186) )
            & ( v4933_9__array(VarNext,A,bitIndex9)
            <=> v7363(VarNext,bitIndex185) )
            & ( v4933_9__array(VarNext,A,bitIndex8)
            <=> v7363(VarNext,bitIndex184) )
            & ( v4933_9__array(VarNext,A,bitIndex7)
            <=> v7363(VarNext,bitIndex183) )
            & ( v4933_9__array(VarNext,A,bitIndex6)
            <=> v7363(VarNext,bitIndex182) )
            & ( v4933_9__array(VarNext,A,bitIndex5)
            <=> v7363(VarNext,bitIndex181) )
            & ( v4933_9__array(VarNext,A,bitIndex4)
            <=> v7363(VarNext,bitIndex180) )
            & ( v4933_9__array(VarNext,A,bitIndex3)
            <=> v7363(VarNext,bitIndex179) )
            & ( v4933_9__array(VarNext,A,bitIndex2)
            <=> v7363(VarNext,bitIndex178) )
            & ( v4933_9__array(VarNext,A,bitIndex1)
            <=> v7363(VarNext,bitIndex177) )
            & ( v4933_9__array(VarNext,A,bitIndex0)
            <=> v7363(VarNext,bitIndex176) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1317,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7357(VarNext)
      <=> ( v7358(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1316,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7358(VarNext)
      <=> ( v7360(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_619,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7360(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_27,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00011_address_term = A
              & v7348(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_8__array(VarNext,A,B)
              <=> v4933_7__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_27,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00011_address_term = A
            & v7348(VarNext) )
         => ( ( v4933_8__array(VarNext,A,bitIndex43)
            <=> v7354(VarNext,bitIndex175) )
            & ( v4933_8__array(VarNext,A,bitIndex42)
            <=> v7354(VarNext,bitIndex174) )
            & ( v4933_8__array(VarNext,A,bitIndex41)
            <=> v7354(VarNext,bitIndex173) )
            & ( v4933_8__array(VarNext,A,bitIndex40)
            <=> v7354(VarNext,bitIndex172) )
            & ( v4933_8__array(VarNext,A,bitIndex39)
            <=> v7354(VarNext,bitIndex171) )
            & ( v4933_8__array(VarNext,A,bitIndex38)
            <=> v7354(VarNext,bitIndex170) )
            & ( v4933_8__array(VarNext,A,bitIndex37)
            <=> v7354(VarNext,bitIndex169) )
            & ( v4933_8__array(VarNext,A,bitIndex36)
            <=> v7354(VarNext,bitIndex168) )
            & ( v4933_8__array(VarNext,A,bitIndex35)
            <=> v7354(VarNext,bitIndex167) )
            & ( v4933_8__array(VarNext,A,bitIndex34)
            <=> v7354(VarNext,bitIndex166) )
            & ( v4933_8__array(VarNext,A,bitIndex33)
            <=> v7354(VarNext,bitIndex165) )
            & ( v4933_8__array(VarNext,A,bitIndex32)
            <=> v7354(VarNext,bitIndex164) )
            & ( v4933_8__array(VarNext,A,bitIndex31)
            <=> v7354(VarNext,bitIndex163) )
            & ( v4933_8__array(VarNext,A,bitIndex30)
            <=> v7354(VarNext,bitIndex162) )
            & ( v4933_8__array(VarNext,A,bitIndex29)
            <=> v7354(VarNext,bitIndex161) )
            & ( v4933_8__array(VarNext,A,bitIndex28)
            <=> v7354(VarNext,bitIndex160) )
            & ( v4933_8__array(VarNext,A,bitIndex27)
            <=> v7354(VarNext,bitIndex159) )
            & ( v4933_8__array(VarNext,A,bitIndex26)
            <=> v7354(VarNext,bitIndex158) )
            & ( v4933_8__array(VarNext,A,bitIndex25)
            <=> v7354(VarNext,bitIndex157) )
            & ( v4933_8__array(VarNext,A,bitIndex24)
            <=> v7354(VarNext,bitIndex156) )
            & ( v4933_8__array(VarNext,A,bitIndex23)
            <=> v7354(VarNext,bitIndex155) )
            & ( v4933_8__array(VarNext,A,bitIndex22)
            <=> v7354(VarNext,bitIndex154) )
            & ( v4933_8__array(VarNext,A,bitIndex21)
            <=> v7354(VarNext,bitIndex153) )
            & ( v4933_8__array(VarNext,A,bitIndex20)
            <=> v7354(VarNext,bitIndex152) )
            & ( v4933_8__array(VarNext,A,bitIndex19)
            <=> v7354(VarNext,bitIndex151) )
            & ( v4933_8__array(VarNext,A,bitIndex18)
            <=> v7354(VarNext,bitIndex150) )
            & ( v4933_8__array(VarNext,A,bitIndex17)
            <=> v7354(VarNext,bitIndex149) )
            & ( v4933_8__array(VarNext,A,bitIndex16)
            <=> v7354(VarNext,bitIndex148) )
            & ( v4933_8__array(VarNext,A,bitIndex15)
            <=> v7354(VarNext,bitIndex147) )
            & ( v4933_8__array(VarNext,A,bitIndex14)
            <=> v7354(VarNext,bitIndex146) )
            & ( v4933_8__array(VarNext,A,bitIndex13)
            <=> v7354(VarNext,bitIndex145) )
            & ( v4933_8__array(VarNext,A,bitIndex12)
            <=> v7354(VarNext,bitIndex144) )
            & ( v4933_8__array(VarNext,A,bitIndex11)
            <=> v7354(VarNext,bitIndex143) )
            & ( v4933_8__array(VarNext,A,bitIndex10)
            <=> v7354(VarNext,bitIndex142) )
            & ( v4933_8__array(VarNext,A,bitIndex9)
            <=> v7354(VarNext,bitIndex141) )
            & ( v4933_8__array(VarNext,A,bitIndex8)
            <=> v7354(VarNext,bitIndex140) )
            & ( v4933_8__array(VarNext,A,bitIndex7)
            <=> v7354(VarNext,bitIndex139) )
            & ( v4933_8__array(VarNext,A,bitIndex6)
            <=> v7354(VarNext,bitIndex138) )
            & ( v4933_8__array(VarNext,A,bitIndex5)
            <=> v7354(VarNext,bitIndex137) )
            & ( v4933_8__array(VarNext,A,bitIndex4)
            <=> v7354(VarNext,bitIndex136) )
            & ( v4933_8__array(VarNext,A,bitIndex3)
            <=> v7354(VarNext,bitIndex135) )
            & ( v4933_8__array(VarNext,A,bitIndex2)
            <=> v7354(VarNext,bitIndex134) )
            & ( v4933_8__array(VarNext,A,bitIndex1)
            <=> v7354(VarNext,bitIndex133) )
            & ( v4933_8__array(VarNext,A,bitIndex0)
            <=> v7354(VarNext,bitIndex132) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1315,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7348(VarNext)
      <=> ( v7349(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1314,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7349(VarNext)
      <=> ( v7351(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_618,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7351(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_26,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00010_address_term = A
              & v7339(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_7__array(VarNext,A,B)
              <=> v4933_6__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_26,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00010_address_term = A
            & v7339(VarNext) )
         => ( ( v4933_7__array(VarNext,A,bitIndex43)
            <=> v7345(VarNext,bitIndex131) )
            & ( v4933_7__array(VarNext,A,bitIndex42)
            <=> v7345(VarNext,bitIndex130) )
            & ( v4933_7__array(VarNext,A,bitIndex41)
            <=> v7345(VarNext,bitIndex129) )
            & ( v4933_7__array(VarNext,A,bitIndex40)
            <=> v7345(VarNext,bitIndex128) )
            & ( v4933_7__array(VarNext,A,bitIndex39)
            <=> v7345(VarNext,bitIndex127) )
            & ( v4933_7__array(VarNext,A,bitIndex38)
            <=> v7345(VarNext,bitIndex126) )
            & ( v4933_7__array(VarNext,A,bitIndex37)
            <=> v7345(VarNext,bitIndex125) )
            & ( v4933_7__array(VarNext,A,bitIndex36)
            <=> v7345(VarNext,bitIndex124) )
            & ( v4933_7__array(VarNext,A,bitIndex35)
            <=> v7345(VarNext,bitIndex123) )
            & ( v4933_7__array(VarNext,A,bitIndex34)
            <=> v7345(VarNext,bitIndex122) )
            & ( v4933_7__array(VarNext,A,bitIndex33)
            <=> v7345(VarNext,bitIndex121) )
            & ( v4933_7__array(VarNext,A,bitIndex32)
            <=> v7345(VarNext,bitIndex120) )
            & ( v4933_7__array(VarNext,A,bitIndex31)
            <=> v7345(VarNext,bitIndex119) )
            & ( v4933_7__array(VarNext,A,bitIndex30)
            <=> v7345(VarNext,bitIndex118) )
            & ( v4933_7__array(VarNext,A,bitIndex29)
            <=> v7345(VarNext,bitIndex117) )
            & ( v4933_7__array(VarNext,A,bitIndex28)
            <=> v7345(VarNext,bitIndex116) )
            & ( v4933_7__array(VarNext,A,bitIndex27)
            <=> v7345(VarNext,bitIndex115) )
            & ( v4933_7__array(VarNext,A,bitIndex26)
            <=> v7345(VarNext,bitIndex114) )
            & ( v4933_7__array(VarNext,A,bitIndex25)
            <=> v7345(VarNext,bitIndex113) )
            & ( v4933_7__array(VarNext,A,bitIndex24)
            <=> v7345(VarNext,bitIndex112) )
            & ( v4933_7__array(VarNext,A,bitIndex23)
            <=> v7345(VarNext,bitIndex111) )
            & ( v4933_7__array(VarNext,A,bitIndex22)
            <=> v7345(VarNext,bitIndex110) )
            & ( v4933_7__array(VarNext,A,bitIndex21)
            <=> v7345(VarNext,bitIndex109) )
            & ( v4933_7__array(VarNext,A,bitIndex20)
            <=> v7345(VarNext,bitIndex108) )
            & ( v4933_7__array(VarNext,A,bitIndex19)
            <=> v7345(VarNext,bitIndex107) )
            & ( v4933_7__array(VarNext,A,bitIndex18)
            <=> v7345(VarNext,bitIndex106) )
            & ( v4933_7__array(VarNext,A,bitIndex17)
            <=> v7345(VarNext,bitIndex105) )
            & ( v4933_7__array(VarNext,A,bitIndex16)
            <=> v7345(VarNext,bitIndex104) )
            & ( v4933_7__array(VarNext,A,bitIndex15)
            <=> v7345(VarNext,bitIndex103) )
            & ( v4933_7__array(VarNext,A,bitIndex14)
            <=> v7345(VarNext,bitIndex102) )
            & ( v4933_7__array(VarNext,A,bitIndex13)
            <=> v7345(VarNext,bitIndex101) )
            & ( v4933_7__array(VarNext,A,bitIndex12)
            <=> v7345(VarNext,bitIndex100) )
            & ( v4933_7__array(VarNext,A,bitIndex11)
            <=> v7345(VarNext,bitIndex99) )
            & ( v4933_7__array(VarNext,A,bitIndex10)
            <=> v7345(VarNext,bitIndex98) )
            & ( v4933_7__array(VarNext,A,bitIndex9)
            <=> v7345(VarNext,bitIndex97) )
            & ( v4933_7__array(VarNext,A,bitIndex8)
            <=> v7345(VarNext,bitIndex96) )
            & ( v4933_7__array(VarNext,A,bitIndex7)
            <=> v7345(VarNext,bitIndex95) )
            & ( v4933_7__array(VarNext,A,bitIndex6)
            <=> v7345(VarNext,bitIndex94) )
            & ( v4933_7__array(VarNext,A,bitIndex5)
            <=> v7345(VarNext,bitIndex93) )
            & ( v4933_7__array(VarNext,A,bitIndex4)
            <=> v7345(VarNext,bitIndex92) )
            & ( v4933_7__array(VarNext,A,bitIndex3)
            <=> v7345(VarNext,bitIndex91) )
            & ( v4933_7__array(VarNext,A,bitIndex2)
            <=> v7345(VarNext,bitIndex90) )
            & ( v4933_7__array(VarNext,A,bitIndex1)
            <=> v7345(VarNext,bitIndex89) )
            & ( v4933_7__array(VarNext,A,bitIndex0)
            <=> v7345(VarNext,bitIndex88) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1313,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7339(VarNext)
      <=> ( v7340(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1312,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7340(VarNext)
      <=> ( v7342(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_617,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7342(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_25,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00001_address_term = A
              & v7330(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_6__array(VarNext,A,B)
              <=> v4933_5__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_25,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00001_address_term = A
            & v7330(VarNext) )
         => ( ( v4933_6__array(VarNext,A,bitIndex43)
            <=> v7336(VarNext,bitIndex87) )
            & ( v4933_6__array(VarNext,A,bitIndex42)
            <=> v7336(VarNext,bitIndex86) )
            & ( v4933_6__array(VarNext,A,bitIndex41)
            <=> v7336(VarNext,bitIndex85) )
            & ( v4933_6__array(VarNext,A,bitIndex40)
            <=> v7336(VarNext,bitIndex84) )
            & ( v4933_6__array(VarNext,A,bitIndex39)
            <=> v7336(VarNext,bitIndex83) )
            & ( v4933_6__array(VarNext,A,bitIndex38)
            <=> v7336(VarNext,bitIndex82) )
            & ( v4933_6__array(VarNext,A,bitIndex37)
            <=> v7336(VarNext,bitIndex81) )
            & ( v4933_6__array(VarNext,A,bitIndex36)
            <=> v7336(VarNext,bitIndex80) )
            & ( v4933_6__array(VarNext,A,bitIndex35)
            <=> v7336(VarNext,bitIndex79) )
            & ( v4933_6__array(VarNext,A,bitIndex34)
            <=> v7336(VarNext,bitIndex78) )
            & ( v4933_6__array(VarNext,A,bitIndex33)
            <=> v7336(VarNext,bitIndex77) )
            & ( v4933_6__array(VarNext,A,bitIndex32)
            <=> v7336(VarNext,bitIndex76) )
            & ( v4933_6__array(VarNext,A,bitIndex31)
            <=> v7336(VarNext,bitIndex75) )
            & ( v4933_6__array(VarNext,A,bitIndex30)
            <=> v7336(VarNext,bitIndex74) )
            & ( v4933_6__array(VarNext,A,bitIndex29)
            <=> v7336(VarNext,bitIndex73) )
            & ( v4933_6__array(VarNext,A,bitIndex28)
            <=> v7336(VarNext,bitIndex72) )
            & ( v4933_6__array(VarNext,A,bitIndex27)
            <=> v7336(VarNext,bitIndex71) )
            & ( v4933_6__array(VarNext,A,bitIndex26)
            <=> v7336(VarNext,bitIndex70) )
            & ( v4933_6__array(VarNext,A,bitIndex25)
            <=> v7336(VarNext,bitIndex69) )
            & ( v4933_6__array(VarNext,A,bitIndex24)
            <=> v7336(VarNext,bitIndex68) )
            & ( v4933_6__array(VarNext,A,bitIndex23)
            <=> v7336(VarNext,bitIndex67) )
            & ( v4933_6__array(VarNext,A,bitIndex22)
            <=> v7336(VarNext,bitIndex66) )
            & ( v4933_6__array(VarNext,A,bitIndex21)
            <=> v7336(VarNext,bitIndex65) )
            & ( v4933_6__array(VarNext,A,bitIndex20)
            <=> v7336(VarNext,bitIndex64) )
            & ( v4933_6__array(VarNext,A,bitIndex19)
            <=> v7336(VarNext,bitIndex63) )
            & ( v4933_6__array(VarNext,A,bitIndex18)
            <=> v7336(VarNext,bitIndex62) )
            & ( v4933_6__array(VarNext,A,bitIndex17)
            <=> v7336(VarNext,bitIndex61) )
            & ( v4933_6__array(VarNext,A,bitIndex16)
            <=> v7336(VarNext,bitIndex60) )
            & ( v4933_6__array(VarNext,A,bitIndex15)
            <=> v7336(VarNext,bitIndex59) )
            & ( v4933_6__array(VarNext,A,bitIndex14)
            <=> v7336(VarNext,bitIndex58) )
            & ( v4933_6__array(VarNext,A,bitIndex13)
            <=> v7336(VarNext,bitIndex57) )
            & ( v4933_6__array(VarNext,A,bitIndex12)
            <=> v7336(VarNext,bitIndex56) )
            & ( v4933_6__array(VarNext,A,bitIndex11)
            <=> v7336(VarNext,bitIndex55) )
            & ( v4933_6__array(VarNext,A,bitIndex10)
            <=> v7336(VarNext,bitIndex54) )
            & ( v4933_6__array(VarNext,A,bitIndex9)
            <=> v7336(VarNext,bitIndex53) )
            & ( v4933_6__array(VarNext,A,bitIndex8)
            <=> v7336(VarNext,bitIndex52) )
            & ( v4933_6__array(VarNext,A,bitIndex7)
            <=> v7336(VarNext,bitIndex51) )
            & ( v4933_6__array(VarNext,A,bitIndex6)
            <=> v7336(VarNext,bitIndex50) )
            & ( v4933_6__array(VarNext,A,bitIndex5)
            <=> v7336(VarNext,bitIndex49) )
            & ( v4933_6__array(VarNext,A,bitIndex4)
            <=> v7336(VarNext,bitIndex48) )
            & ( v4933_6__array(VarNext,A,bitIndex3)
            <=> v7336(VarNext,bitIndex47) )
            & ( v4933_6__array(VarNext,A,bitIndex2)
            <=> v7336(VarNext,bitIndex46) )
            & ( v4933_6__array(VarNext,A,bitIndex1)
            <=> v7336(VarNext,bitIndex45) )
            & ( v4933_6__array(VarNext,A,bitIndex0)
            <=> v7336(VarNext,bitIndex44) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1311,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7330(VarNext)
      <=> ( v7331(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1310,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7331(VarNext)
      <=> ( v7333(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_616,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7333(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_24,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b00000_address_term = A
              & v7316(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_5__array(VarNext,A,B)
              <=> v4933_4__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_24,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b00000_address_term = A
            & v7316(VarNext) )
         => ! [B] :
              ( range_43_0(B)
             => ( v4933_5__array(VarNext,A,B)
              <=> v7327(VarNext,B) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1309,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7316(VarNext)
      <=> ( v7317(VarNext)
          & v7323(VarNext) ) ) ) ).

fof(addAssignment_1789,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7323(VarNext)
      <=> v7321(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1308,axiom,
    ! [VarCurr] :
      ( v7321(VarCurr)
    <=> ( v7279(VarCurr)
        & v7324(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_479,axiom,
    ! [VarCurr] :
      ( v7324(VarCurr)
    <=> ( ( v7325(VarCurr,bitIndex1)
        <=> $false )
        & ( v7325(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1788,axiom,
    ! [VarCurr] :
      ( v7325(VarCurr,bitIndex0)
    <=> v5270(VarCurr) ) ).

fof(addAssignment_1787,axiom,
    ! [VarCurr] :
      ( v7325(VarCurr,bitIndex1)
    <=> v4944(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1307,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7317(VarNext)
      <=> ( v7319(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_615,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7319(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_23,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v6241_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ~ ( A = AssociatedAddressVar
                  & v7304(VarNext) )
             => ! [B] :
                  ( range_43_0(B)
                 => ( v4933_4__array(VarNext,A,B)
                  <=> v4933_3__array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_23,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v6241_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ( A = AssociatedAddressVar
                & v7304(VarNext) )
             => ! [B] :
                  ( range_43_0(B)
                 => ( v4933_4__array(VarNext,A,B)
                  <=> v5627(VarNext,B) ) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1306,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7304(VarNext)
      <=> ( v7305(VarNext)
          & v7311(VarNext) ) ) ) ).

fof(addAssignment_1786,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7311(VarNext)
      <=> v7309(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1305,axiom,
    ! [VarCurr] :
      ( v7309(VarCurr)
    <=> ( v7279(VarCurr)
        & v7312(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_478,axiom,
    ! [VarCurr] :
      ( v7312(VarCurr)
    <=> ( ( v7313(VarCurr,bitIndex1)
        <=> $true )
        & ( v7313(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1785,axiom,
    ! [VarCurr] :
      ( v7313(VarCurr,bitIndex0)
    <=> v5270(VarCurr) ) ).

fof(addAssignment_1784,axiom,
    ! [VarCurr] :
      ( v7313(VarCurr,bitIndex1)
    <=> v4944(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1304,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7305(VarNext)
      <=> ( v7307(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_614,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7307(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_22,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v6281_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ~ ( A = AssociatedAddressVar
                  & v7292(VarNext) )
             => ! [B] :
                  ( range_43_0(B)
                 => ( v4933_3__array(VarNext,A,B)
                  <=> v4933_2__array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_22,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v6281_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ( A = AssociatedAddressVar
                & v7292(VarNext) )
             => ! [B] :
                  ( range_43_0(B)
                 => ( v4933_3__array(VarNext,A,B)
                  <=> v6273(VarNext,B) ) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1303,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7292(VarNext)
      <=> ( v7293(VarNext)
          & v7299(VarNext) ) ) ) ).

fof(addAssignment_1783,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7299(VarNext)
      <=> v7297(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1302,axiom,
    ! [VarCurr] :
      ( v7297(VarCurr)
    <=> ( v7279(VarCurr)
        & v7300(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_477,axiom,
    ! [VarCurr] :
      ( v7300(VarCurr)
    <=> ( ( v7301(VarCurr,bitIndex1)
        <=> $false )
        & ( v7301(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1782,axiom,
    ! [VarCurr] :
      ( v7301(VarCurr,bitIndex0)
    <=> v5270(VarCurr) ) ).

fof(addAssignment_1781,axiom,
    ! [VarCurr] :
      ( v7301(VarCurr,bitIndex1)
    <=> v4944(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1301,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7293(VarNext)
      <=> ( v7295(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_613,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7295(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_21,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v6281_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ~ ( A = AssociatedAddressVar
                  & v7285(VarNext) )
             => ! [B] :
                  ( range_43_0(B)
                 => ( v4933_2__array(VarNext,A,B)
                  <=> v4933_1__array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_21,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v6281_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ( A = AssociatedAddressVar
                & v7285(VarNext) )
             => ! [B] :
                  ( range_43_0(B)
                 => ( v4933_2__array(VarNext,A,B)
                  <=> v6273(VarNext,B) ) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1300,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7285(VarNext)
      <=> ( v7286(VarNext)
          & v7278(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1299,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7286(VarNext)
      <=> ( v7288(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_612,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7288(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(memoryWriteDisabled_20,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v6241_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ~ ( A = AssociatedAddressVar
                  & v7269(VarNext) )
             => ! [B] :
                  ( range_43_0(B)
                 => ( v4933_1__array(VarNext,A,B)
                  <=> v4933_array(VarCurr,A,B) ) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_20,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v6241_range_4_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ( A = AssociatedAddressVar
                & v7269(VarNext) )
             => ! [B] :
                  ( range_43_0(B)
                 => ( v4933_1__array(VarNext,A,B)
                  <=> v5627(VarNext,B) ) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1298,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7269(VarNext)
      <=> ( v7270(VarNext)
          & v7278(VarNext) ) ) ) ).

fof(addAssignment_1780,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7278(VarNext)
      <=> v7276(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1297,axiom,
    ! [VarCurr] :
      ( v7276(VarCurr)
    <=> ( v7279(VarCurr)
        & v7281(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_476,axiom,
    ! [VarCurr] :
      ( v7281(VarCurr)
    <=> ( ( v7282(VarCurr,bitIndex1)
        <=> $true )
        & ( v7282(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1779,axiom,
    ! [VarCurr] :
      ( v7282(VarCurr,bitIndex0)
    <=> v5270(VarCurr) ) ).

fof(addAssignment_1778,axiom,
    ! [VarCurr] :
      ( v7282(VarCurr,bitIndex1)
    <=> v4944(VarCurr) ) ).

fof(writeUnaryOperator_611,axiom,
    ! [VarCurr] :
      ( ~ v7279(VarCurr)
    <=> v7280(VarCurr) ) ).

fof(writeUnaryOperator_610,axiom,
    ! [VarCurr] :
      ( ~ v7280(VarCurr)
    <=> v4940(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1296,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7270(VarNext)
      <=> ( v7271(VarNext)
          & v4935(VarNext) ) ) ) ).

fof(writeUnaryOperator_609,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7271(VarNext)
      <=> v7273(VarNext) ) ) ).

fof(addAssignment_1777,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7273(VarNext)
      <=> v4935(VarCurr) ) ) ).

fof(initSateConstraint_1247,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex0) ).

fof(initSateConstraint_1246,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex1) ).

fof(initSateConstraint_1245,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex2) ).

fof(initSateConstraint_1244,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex3) ).

fof(initSateConstraint_1243,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex4) ).

fof(initSateConstraint_1242,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex5) ).

fof(initSateConstraint_1241,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex6) ).

fof(initSateConstraint_1240,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex7) ).

fof(initSateConstraint_1239,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex8) ).

fof(initSateConstraint_1238,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex9) ).

fof(initSateConstraint_1237,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex10) ).

fof(initSateConstraint_1236,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex11) ).

fof(initSateConstraint_1235,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex12) ).

fof(initSateConstraint_1234,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex13) ).

fof(initSateConstraint_1233,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex14) ).

fof(initSateConstraint_1232,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex15) ).

fof(initSateConstraint_1231,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex16) ).

fof(initSateConstraint_1230,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex17) ).

fof(initSateConstraint_1229,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex18) ).

fof(initSateConstraint_1228,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex19) ).

fof(initSateConstraint_1227,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex20) ).

fof(initSateConstraint_1226,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex21) ).

fof(initSateConstraint_1225,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex22) ).

fof(initSateConstraint_1224,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex23) ).

fof(initSateConstraint_1223,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex24) ).

fof(initSateConstraint_1222,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex25) ).

fof(initSateConstraint_1221,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex26) ).

fof(initSateConstraint_1220,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex27) ).

fof(initSateConstraint_1219,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex28) ).

fof(initSateConstraint_1218,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex29) ).

fof(initSateConstraint_1217,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex30) ).

fof(initSateConstraint_1216,axiom,
    ~ v4933_array(constB0,b11111_address_term,bitIndex31) ).

fof(initSateConstraint_1215,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex0) ).

fof(initSateConstraint_1214,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex1) ).

fof(initSateConstraint_1213,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex2) ).

fof(initSateConstraint_1212,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex3) ).

fof(initSateConstraint_1211,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex4) ).

fof(initSateConstraint_1210,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex5) ).

fof(initSateConstraint_1209,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex6) ).

fof(initSateConstraint_1208,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex7) ).

fof(initSateConstraint_1207,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex8) ).

fof(initSateConstraint_1206,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex9) ).

fof(initSateConstraint_1205,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex10) ).

fof(initSateConstraint_1204,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex11) ).

fof(initSateConstraint_1203,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex12) ).

fof(initSateConstraint_1202,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex13) ).

fof(initSateConstraint_1201,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex14) ).

fof(initSateConstraint_1200,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex15) ).

fof(initSateConstraint_1199,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex16) ).

fof(initSateConstraint_1198,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex17) ).

fof(initSateConstraint_1197,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex18) ).

fof(initSateConstraint_1196,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex19) ).

fof(initSateConstraint_1195,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex20) ).

fof(initSateConstraint_1194,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex21) ).

fof(initSateConstraint_1193,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex22) ).

fof(initSateConstraint_1192,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex23) ).

fof(initSateConstraint_1191,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex24) ).

fof(initSateConstraint_1190,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex25) ).

fof(initSateConstraint_1189,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex26) ).

fof(initSateConstraint_1188,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex27) ).

fof(initSateConstraint_1187,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex28) ).

fof(initSateConstraint_1186,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex29) ).

fof(initSateConstraint_1185,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex30) ).

fof(initSateConstraint_1184,axiom,
    ~ v4933_array(constB0,b11110_address_term,bitIndex31) ).

fof(initSateConstraint_1183,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex0) ).

fof(initSateConstraint_1182,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex1) ).

fof(initSateConstraint_1181,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex2) ).

fof(initSateConstraint_1180,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex3) ).

fof(initSateConstraint_1179,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex4) ).

fof(initSateConstraint_1178,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex5) ).

fof(initSateConstraint_1177,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex6) ).

fof(initSateConstraint_1176,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex7) ).

fof(initSateConstraint_1175,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex8) ).

fof(initSateConstraint_1174,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex9) ).

fof(initSateConstraint_1173,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex10) ).

fof(initSateConstraint_1172,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex11) ).

fof(initSateConstraint_1171,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex12) ).

fof(initSateConstraint_1170,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex13) ).

fof(initSateConstraint_1169,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex14) ).

fof(initSateConstraint_1168,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex15) ).

fof(initSateConstraint_1167,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex16) ).

fof(initSateConstraint_1166,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex17) ).

fof(initSateConstraint_1165,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex18) ).

fof(initSateConstraint_1164,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex19) ).

fof(initSateConstraint_1163,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex20) ).

fof(initSateConstraint_1162,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex21) ).

fof(initSateConstraint_1161,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex22) ).

fof(initSateConstraint_1160,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex23) ).

fof(initSateConstraint_1159,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex24) ).

fof(initSateConstraint_1158,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex25) ).

fof(initSateConstraint_1157,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex26) ).

fof(initSateConstraint_1156,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex27) ).

fof(initSateConstraint_1155,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex28) ).

fof(initSateConstraint_1154,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex29) ).

fof(initSateConstraint_1153,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex30) ).

fof(initSateConstraint_1152,axiom,
    ~ v4933_array(constB0,b11101_address_term,bitIndex31) ).

fof(initSateConstraint_1151,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex0) ).

fof(initSateConstraint_1150,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex1) ).

fof(initSateConstraint_1149,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex2) ).

fof(initSateConstraint_1148,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex3) ).

fof(initSateConstraint_1147,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex4) ).

fof(initSateConstraint_1146,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex5) ).

fof(initSateConstraint_1145,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex6) ).

fof(initSateConstraint_1144,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex7) ).

fof(initSateConstraint_1143,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex8) ).

fof(initSateConstraint_1142,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex9) ).

fof(initSateConstraint_1141,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex10) ).

fof(initSateConstraint_1140,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex11) ).

fof(initSateConstraint_1139,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex12) ).

fof(initSateConstraint_1138,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex13) ).

fof(initSateConstraint_1137,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex14) ).

fof(initSateConstraint_1136,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex15) ).

fof(initSateConstraint_1135,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex16) ).

fof(initSateConstraint_1134,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex17) ).

fof(initSateConstraint_1133,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex18) ).

fof(initSateConstraint_1132,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex19) ).

fof(initSateConstraint_1131,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex20) ).

fof(initSateConstraint_1130,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex21) ).

fof(initSateConstraint_1129,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex22) ).

fof(initSateConstraint_1128,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex23) ).

fof(initSateConstraint_1127,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex24) ).

fof(initSateConstraint_1126,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex25) ).

fof(initSateConstraint_1125,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex26) ).

fof(initSateConstraint_1124,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex27) ).

fof(initSateConstraint_1123,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex28) ).

fof(initSateConstraint_1122,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex29) ).

fof(initSateConstraint_1121,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex30) ).

fof(initSateConstraint_1120,axiom,
    ~ v4933_array(constB0,b11100_address_term,bitIndex31) ).

fof(initSateConstraint_1119,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex0) ).

fof(initSateConstraint_1118,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex1) ).

fof(initSateConstraint_1117,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex2) ).

fof(initSateConstraint_1116,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex3) ).

fof(initSateConstraint_1115,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex4) ).

fof(initSateConstraint_1114,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex5) ).

fof(initSateConstraint_1113,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex6) ).

fof(initSateConstraint_1112,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex7) ).

fof(initSateConstraint_1111,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex8) ).

fof(initSateConstraint_1110,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex9) ).

fof(initSateConstraint_1109,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex10) ).

fof(initSateConstraint_1108,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex11) ).

fof(initSateConstraint_1107,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex12) ).

fof(initSateConstraint_1106,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex13) ).

fof(initSateConstraint_1105,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex14) ).

fof(initSateConstraint_1104,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex15) ).

fof(initSateConstraint_1103,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex16) ).

fof(initSateConstraint_1102,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex17) ).

fof(initSateConstraint_1101,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex18) ).

fof(initSateConstraint_1100,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex19) ).

fof(initSateConstraint_1099,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex20) ).

fof(initSateConstraint_1098,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex21) ).

fof(initSateConstraint_1097,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex22) ).

fof(initSateConstraint_1096,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex23) ).

fof(initSateConstraint_1095,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex24) ).

fof(initSateConstraint_1094,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex25) ).

fof(initSateConstraint_1093,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex26) ).

fof(initSateConstraint_1092,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex27) ).

fof(initSateConstraint_1091,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex28) ).

fof(initSateConstraint_1090,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex29) ).

fof(initSateConstraint_1089,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex30) ).

fof(initSateConstraint_1088,axiom,
    ~ v4933_array(constB0,b11011_address_term,bitIndex31) ).

fof(initSateConstraint_1087,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex0) ).

fof(initSateConstraint_1086,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex1) ).

fof(initSateConstraint_1085,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex2) ).

fof(initSateConstraint_1084,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex3) ).

fof(initSateConstraint_1083,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex4) ).

fof(initSateConstraint_1082,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex5) ).

fof(initSateConstraint_1081,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex6) ).

fof(initSateConstraint_1080,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex7) ).

fof(initSateConstraint_1079,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex8) ).

fof(initSateConstraint_1078,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex9) ).

fof(initSateConstraint_1077,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex10) ).

fof(initSateConstraint_1076,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex11) ).

fof(initSateConstraint_1075,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex12) ).

fof(initSateConstraint_1074,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex13) ).

fof(initSateConstraint_1073,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex14) ).

fof(initSateConstraint_1072,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex15) ).

fof(initSateConstraint_1071,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex16) ).

fof(initSateConstraint_1070,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex17) ).

fof(initSateConstraint_1069,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex18) ).

fof(initSateConstraint_1068,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex19) ).

fof(initSateConstraint_1067,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex20) ).

fof(initSateConstraint_1066,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex21) ).

fof(initSateConstraint_1065,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex22) ).

fof(initSateConstraint_1064,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex23) ).

fof(initSateConstraint_1063,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex24) ).

fof(initSateConstraint_1062,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex25) ).

fof(initSateConstraint_1061,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex26) ).

fof(initSateConstraint_1060,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex27) ).

fof(initSateConstraint_1059,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex28) ).

fof(initSateConstraint_1058,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex29) ).

fof(initSateConstraint_1057,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex30) ).

fof(initSateConstraint_1056,axiom,
    ~ v4933_array(constB0,b11010_address_term,bitIndex31) ).

fof(initSateConstraint_1055,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex0) ).

fof(initSateConstraint_1054,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex1) ).

fof(initSateConstraint_1053,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex2) ).

fof(initSateConstraint_1052,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex3) ).

fof(initSateConstraint_1051,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex4) ).

fof(initSateConstraint_1050,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex5) ).

fof(initSateConstraint_1049,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex6) ).

fof(initSateConstraint_1048,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex7) ).

fof(initSateConstraint_1047,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex8) ).

fof(initSateConstraint_1046,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex9) ).

fof(initSateConstraint_1045,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex10) ).

fof(initSateConstraint_1044,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex11) ).

fof(initSateConstraint_1043,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex12) ).

fof(initSateConstraint_1042,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex13) ).

fof(initSateConstraint_1041,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex14) ).

fof(initSateConstraint_1040,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex15) ).

fof(initSateConstraint_1039,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex16) ).

fof(initSateConstraint_1038,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex17) ).

fof(initSateConstraint_1037,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex18) ).

fof(initSateConstraint_1036,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex19) ).

fof(initSateConstraint_1035,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex20) ).

fof(initSateConstraint_1034,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex21) ).

fof(initSateConstraint_1033,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex22) ).

fof(initSateConstraint_1032,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex23) ).

fof(initSateConstraint_1031,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex24) ).

fof(initSateConstraint_1030,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex25) ).

fof(initSateConstraint_1029,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex26) ).

fof(initSateConstraint_1028,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex27) ).

fof(initSateConstraint_1027,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex28) ).

fof(initSateConstraint_1026,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex29) ).

fof(initSateConstraint_1025,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex30) ).

fof(initSateConstraint_1024,axiom,
    ~ v4933_array(constB0,b11001_address_term,bitIndex31) ).

fof(initSateConstraint_1023,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex0) ).

fof(initSateConstraint_1022,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex1) ).

fof(initSateConstraint_1021,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex2) ).

fof(initSateConstraint_1020,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex3) ).

fof(initSateConstraint_1019,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex4) ).

fof(initSateConstraint_1018,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex5) ).

fof(initSateConstraint_1017,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex6) ).

fof(initSateConstraint_1016,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex7) ).

fof(initSateConstraint_1015,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex8) ).

fof(initSateConstraint_1014,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex9) ).

fof(initSateConstraint_1013,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex10) ).

fof(initSateConstraint_1012,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex11) ).

fof(initSateConstraint_1011,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex12) ).

fof(initSateConstraint_1010,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex13) ).

fof(initSateConstraint_1009,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex14) ).

fof(initSateConstraint_1008,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex15) ).

fof(initSateConstraint_1007,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex16) ).

fof(initSateConstraint_1006,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex17) ).

fof(initSateConstraint_1005,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex18) ).

fof(initSateConstraint_1004,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex19) ).

fof(initSateConstraint_1003,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex20) ).

fof(initSateConstraint_1002,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex21) ).

fof(initSateConstraint_1001,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex22) ).

fof(initSateConstraint_1000,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex23) ).

fof(initSateConstraint_999,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex24) ).

fof(initSateConstraint_998,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex25) ).

fof(initSateConstraint_997,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex26) ).

fof(initSateConstraint_996,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex27) ).

fof(initSateConstraint_995,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex28) ).

fof(initSateConstraint_994,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex29) ).

fof(initSateConstraint_993,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex30) ).

fof(initSateConstraint_992,axiom,
    ~ v4933_array(constB0,b11000_address_term,bitIndex31) ).

fof(initSateConstraint_991,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex0) ).

fof(initSateConstraint_990,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex1) ).

fof(initSateConstraint_989,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex2) ).

fof(initSateConstraint_988,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex3) ).

fof(initSateConstraint_987,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex4) ).

fof(initSateConstraint_986,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex5) ).

fof(initSateConstraint_985,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex6) ).

fof(initSateConstraint_984,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex7) ).

fof(initSateConstraint_983,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex8) ).

fof(initSateConstraint_982,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex9) ).

fof(initSateConstraint_981,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex10) ).

fof(initSateConstraint_980,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex11) ).

fof(initSateConstraint_979,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex12) ).

fof(initSateConstraint_978,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex13) ).

fof(initSateConstraint_977,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex14) ).

fof(initSateConstraint_976,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex15) ).

fof(initSateConstraint_975,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex16) ).

fof(initSateConstraint_974,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex17) ).

fof(initSateConstraint_973,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex18) ).

fof(initSateConstraint_972,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex19) ).

fof(initSateConstraint_971,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex20) ).

fof(initSateConstraint_970,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex21) ).

fof(initSateConstraint_969,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex22) ).

fof(initSateConstraint_968,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex23) ).

fof(initSateConstraint_967,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex24) ).

fof(initSateConstraint_966,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex25) ).

fof(initSateConstraint_965,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex26) ).

fof(initSateConstraint_964,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex27) ).

fof(initSateConstraint_963,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex28) ).

fof(initSateConstraint_962,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex29) ).

fof(initSateConstraint_961,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex30) ).

fof(initSateConstraint_960,axiom,
    ~ v4933_array(constB0,b10111_address_term,bitIndex31) ).

fof(initSateConstraint_959,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex0) ).

fof(initSateConstraint_958,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex1) ).

fof(initSateConstraint_957,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex2) ).

fof(initSateConstraint_956,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex3) ).

fof(initSateConstraint_955,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex4) ).

fof(initSateConstraint_954,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex5) ).

fof(initSateConstraint_953,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex6) ).

fof(initSateConstraint_952,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex7) ).

fof(initSateConstraint_951,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex8) ).

fof(initSateConstraint_950,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex9) ).

fof(initSateConstraint_949,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex10) ).

fof(initSateConstraint_948,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex11) ).

fof(initSateConstraint_947,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex12) ).

fof(initSateConstraint_946,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex13) ).

fof(initSateConstraint_945,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex14) ).

fof(initSateConstraint_944,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex15) ).

fof(initSateConstraint_943,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex16) ).

fof(initSateConstraint_942,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex17) ).

fof(initSateConstraint_941,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex18) ).

fof(initSateConstraint_940,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex19) ).

fof(initSateConstraint_939,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex20) ).

fof(initSateConstraint_938,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex21) ).

fof(initSateConstraint_937,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex22) ).

fof(initSateConstraint_936,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex23) ).

fof(initSateConstraint_935,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex24) ).

fof(initSateConstraint_934,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex25) ).

fof(initSateConstraint_933,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex26) ).

fof(initSateConstraint_932,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex27) ).

fof(initSateConstraint_931,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex28) ).

fof(initSateConstraint_930,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex29) ).

fof(initSateConstraint_929,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex30) ).

fof(initSateConstraint_928,axiom,
    ~ v4933_array(constB0,b10110_address_term,bitIndex31) ).

fof(initSateConstraint_927,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex0) ).

fof(initSateConstraint_926,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex1) ).

fof(initSateConstraint_925,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex2) ).

fof(initSateConstraint_924,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex3) ).

fof(initSateConstraint_923,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex4) ).

fof(initSateConstraint_922,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex5) ).

fof(initSateConstraint_921,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex6) ).

fof(initSateConstraint_920,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex7) ).

fof(initSateConstraint_919,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex8) ).

fof(initSateConstraint_918,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex9) ).

fof(initSateConstraint_917,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex10) ).

fof(initSateConstraint_916,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex11) ).

fof(initSateConstraint_915,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex12) ).

fof(initSateConstraint_914,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex13) ).

fof(initSateConstraint_913,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex14) ).

fof(initSateConstraint_912,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex15) ).

fof(initSateConstraint_911,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex16) ).

fof(initSateConstraint_910,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex17) ).

fof(initSateConstraint_909,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex18) ).

fof(initSateConstraint_908,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex19) ).

fof(initSateConstraint_907,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex20) ).

fof(initSateConstraint_906,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex21) ).

fof(initSateConstraint_905,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex22) ).

fof(initSateConstraint_904,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex23) ).

fof(initSateConstraint_903,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex24) ).

fof(initSateConstraint_902,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex25) ).

fof(initSateConstraint_901,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex26) ).

fof(initSateConstraint_900,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex27) ).

fof(initSateConstraint_899,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex28) ).

fof(initSateConstraint_898,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex29) ).

fof(initSateConstraint_897,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex30) ).

fof(initSateConstraint_896,axiom,
    ~ v4933_array(constB0,b10101_address_term,bitIndex31) ).

fof(initSateConstraint_895,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex0) ).

fof(initSateConstraint_894,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex1) ).

fof(initSateConstraint_893,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex2) ).

fof(initSateConstraint_892,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex3) ).

fof(initSateConstraint_891,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex4) ).

fof(initSateConstraint_890,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex5) ).

fof(initSateConstraint_889,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex6) ).

fof(initSateConstraint_888,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex7) ).

fof(initSateConstraint_887,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex8) ).

fof(initSateConstraint_886,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex9) ).

fof(initSateConstraint_885,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex10) ).

fof(initSateConstraint_884,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex11) ).

fof(initSateConstraint_883,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex12) ).

fof(initSateConstraint_882,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex13) ).

fof(initSateConstraint_881,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex14) ).

fof(initSateConstraint_880,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex15) ).

fof(initSateConstraint_879,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex16) ).

fof(initSateConstraint_878,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex17) ).

fof(initSateConstraint_877,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex18) ).

fof(initSateConstraint_876,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex19) ).

fof(initSateConstraint_875,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex20) ).

fof(initSateConstraint_874,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex21) ).

fof(initSateConstraint_873,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex22) ).

fof(initSateConstraint_872,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex23) ).

fof(initSateConstraint_871,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex24) ).

fof(initSateConstraint_870,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex25) ).

fof(initSateConstraint_869,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex26) ).

fof(initSateConstraint_868,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex27) ).

fof(initSateConstraint_867,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex28) ).

fof(initSateConstraint_866,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex29) ).

fof(initSateConstraint_865,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex30) ).

fof(initSateConstraint_864,axiom,
    ~ v4933_array(constB0,b10100_address_term,bitIndex31) ).

fof(initSateConstraint_863,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex0) ).

fof(initSateConstraint_862,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex1) ).

fof(initSateConstraint_861,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex2) ).

fof(initSateConstraint_860,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex3) ).

fof(initSateConstraint_859,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex4) ).

fof(initSateConstraint_858,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex5) ).

fof(initSateConstraint_857,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex6) ).

fof(initSateConstraint_856,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex7) ).

fof(initSateConstraint_855,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex8) ).

fof(initSateConstraint_854,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex9) ).

fof(initSateConstraint_853,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex10) ).

fof(initSateConstraint_852,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex11) ).

fof(initSateConstraint_851,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex12) ).

fof(initSateConstraint_850,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex13) ).

fof(initSateConstraint_849,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex14) ).

fof(initSateConstraint_848,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex15) ).

fof(initSateConstraint_847,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex16) ).

fof(initSateConstraint_846,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex17) ).

fof(initSateConstraint_845,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex18) ).

fof(initSateConstraint_844,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex19) ).

fof(initSateConstraint_843,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex20) ).

fof(initSateConstraint_842,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex21) ).

fof(initSateConstraint_841,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex22) ).

fof(initSateConstraint_840,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex23) ).

fof(initSateConstraint_839,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex24) ).

fof(initSateConstraint_838,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex25) ).

fof(initSateConstraint_837,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex26) ).

fof(initSateConstraint_836,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex27) ).

fof(initSateConstraint_835,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex28) ).

fof(initSateConstraint_834,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex29) ).

fof(initSateConstraint_833,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex30) ).

fof(initSateConstraint_832,axiom,
    ~ v4933_array(constB0,b10011_address_term,bitIndex31) ).

fof(initSateConstraint_831,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex0) ).

fof(initSateConstraint_830,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex1) ).

fof(initSateConstraint_829,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex2) ).

fof(initSateConstraint_828,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex3) ).

fof(initSateConstraint_827,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex4) ).

fof(initSateConstraint_826,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex5) ).

fof(initSateConstraint_825,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex6) ).

fof(initSateConstraint_824,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex7) ).

fof(initSateConstraint_823,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex8) ).

fof(initSateConstraint_822,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex9) ).

fof(initSateConstraint_821,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex10) ).

fof(initSateConstraint_820,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex11) ).

fof(initSateConstraint_819,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex12) ).

fof(initSateConstraint_818,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex13) ).

fof(initSateConstraint_817,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex14) ).

fof(initSateConstraint_816,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex15) ).

fof(initSateConstraint_815,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex16) ).

fof(initSateConstraint_814,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex17) ).

fof(initSateConstraint_813,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex18) ).

fof(initSateConstraint_812,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex19) ).

fof(initSateConstraint_811,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex20) ).

fof(initSateConstraint_810,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex21) ).

fof(initSateConstraint_809,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex22) ).

fof(initSateConstraint_808,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex23) ).

fof(initSateConstraint_807,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex24) ).

fof(initSateConstraint_806,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex25) ).

fof(initSateConstraint_805,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex26) ).

fof(initSateConstraint_804,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex27) ).

fof(initSateConstraint_803,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex28) ).

fof(initSateConstraint_802,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex29) ).

fof(initSateConstraint_801,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex30) ).

fof(initSateConstraint_800,axiom,
    ~ v4933_array(constB0,b10010_address_term,bitIndex31) ).

fof(initSateConstraint_799,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex0) ).

fof(initSateConstraint_798,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex1) ).

fof(initSateConstraint_797,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex2) ).

fof(initSateConstraint_796,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex3) ).

fof(initSateConstraint_795,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex4) ).

fof(initSateConstraint_794,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex5) ).

fof(initSateConstraint_793,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex6) ).

fof(initSateConstraint_792,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex7) ).

fof(initSateConstraint_791,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex8) ).

fof(initSateConstraint_790,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex9) ).

fof(initSateConstraint_789,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex10) ).

fof(initSateConstraint_788,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex11) ).

fof(initSateConstraint_787,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex12) ).

fof(initSateConstraint_786,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex13) ).

fof(initSateConstraint_785,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex14) ).

fof(initSateConstraint_784,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex15) ).

fof(initSateConstraint_783,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex16) ).

fof(initSateConstraint_782,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex17) ).

fof(initSateConstraint_781,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex18) ).

fof(initSateConstraint_780,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex19) ).

fof(initSateConstraint_779,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex20) ).

fof(initSateConstraint_778,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex21) ).

fof(initSateConstraint_777,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex22) ).

fof(initSateConstraint_776,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex23) ).

fof(initSateConstraint_775,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex24) ).

fof(initSateConstraint_774,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex25) ).

fof(initSateConstraint_773,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex26) ).

fof(initSateConstraint_772,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex27) ).

fof(initSateConstraint_771,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex28) ).

fof(initSateConstraint_770,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex29) ).

fof(initSateConstraint_769,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex30) ).

fof(initSateConstraint_768,axiom,
    ~ v4933_array(constB0,b10001_address_term,bitIndex31) ).

fof(initSateConstraint_767,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex0) ).

fof(initSateConstraint_766,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex1) ).

fof(initSateConstraint_765,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex2) ).

fof(initSateConstraint_764,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex3) ).

fof(initSateConstraint_763,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex4) ).

fof(initSateConstraint_762,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex5) ).

fof(initSateConstraint_761,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex6) ).

fof(initSateConstraint_760,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex7) ).

fof(initSateConstraint_759,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex8) ).

fof(initSateConstraint_758,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex9) ).

fof(initSateConstraint_757,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex10) ).

fof(initSateConstraint_756,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex11) ).

fof(initSateConstraint_755,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex12) ).

fof(initSateConstraint_754,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex13) ).

fof(initSateConstraint_753,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex14) ).

fof(initSateConstraint_752,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex15) ).

fof(initSateConstraint_751,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex16) ).

fof(initSateConstraint_750,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex17) ).

fof(initSateConstraint_749,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex18) ).

fof(initSateConstraint_748,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex19) ).

fof(initSateConstraint_747,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex20) ).

fof(initSateConstraint_746,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex21) ).

fof(initSateConstraint_745,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex22) ).

fof(initSateConstraint_744,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex23) ).

fof(initSateConstraint_743,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex24) ).

fof(initSateConstraint_742,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex25) ).

fof(initSateConstraint_741,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex26) ).

fof(initSateConstraint_740,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex27) ).

fof(initSateConstraint_739,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex28) ).

fof(initSateConstraint_738,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex29) ).

fof(initSateConstraint_737,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex30) ).

fof(initSateConstraint_736,axiom,
    ~ v4933_array(constB0,b10000_address_term,bitIndex31) ).

fof(initSateConstraint_735,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex0) ).

fof(initSateConstraint_734,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex1) ).

fof(initSateConstraint_733,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex2) ).

fof(initSateConstraint_732,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex3) ).

fof(initSateConstraint_731,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex4) ).

fof(initSateConstraint_730,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex5) ).

fof(initSateConstraint_729,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex6) ).

fof(initSateConstraint_728,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex7) ).

fof(initSateConstraint_727,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex8) ).

fof(initSateConstraint_726,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex9) ).

fof(initSateConstraint_725,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex10) ).

fof(initSateConstraint_724,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex11) ).

fof(initSateConstraint_723,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex12) ).

fof(initSateConstraint_722,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex13) ).

fof(initSateConstraint_721,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex14) ).

fof(initSateConstraint_720,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex15) ).

fof(initSateConstraint_719,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex16) ).

fof(initSateConstraint_718,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex17) ).

fof(initSateConstraint_717,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex18) ).

fof(initSateConstraint_716,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex19) ).

fof(initSateConstraint_715,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex20) ).

fof(initSateConstraint_714,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex21) ).

fof(initSateConstraint_713,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex22) ).

fof(initSateConstraint_712,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex23) ).

fof(initSateConstraint_711,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex24) ).

fof(initSateConstraint_710,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex25) ).

fof(initSateConstraint_709,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex26) ).

fof(initSateConstraint_708,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex27) ).

fof(initSateConstraint_707,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex28) ).

fof(initSateConstraint_706,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex29) ).

fof(initSateConstraint_705,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex30) ).

fof(initSateConstraint_704,axiom,
    ~ v4933_array(constB0,b01111_address_term,bitIndex31) ).

fof(initSateConstraint_703,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex0) ).

fof(initSateConstraint_702,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex1) ).

fof(initSateConstraint_701,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex2) ).

fof(initSateConstraint_700,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex3) ).

fof(initSateConstraint_699,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex4) ).

fof(initSateConstraint_698,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex5) ).

fof(initSateConstraint_697,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex6) ).

fof(initSateConstraint_696,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex7) ).

fof(initSateConstraint_695,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex8) ).

fof(initSateConstraint_694,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex9) ).

fof(initSateConstraint_693,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex10) ).

fof(initSateConstraint_692,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex11) ).

fof(initSateConstraint_691,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex12) ).

fof(initSateConstraint_690,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex13) ).

fof(initSateConstraint_689,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex14) ).

fof(initSateConstraint_688,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex15) ).

fof(initSateConstraint_687,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex16) ).

fof(initSateConstraint_686,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex17) ).

fof(initSateConstraint_685,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex18) ).

fof(initSateConstraint_684,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex19) ).

fof(initSateConstraint_683,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex20) ).

fof(initSateConstraint_682,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex21) ).

fof(initSateConstraint_681,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex22) ).

fof(initSateConstraint_680,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex23) ).

fof(initSateConstraint_679,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex24) ).

fof(initSateConstraint_678,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex25) ).

fof(initSateConstraint_677,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex26) ).

fof(initSateConstraint_676,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex27) ).

fof(initSateConstraint_675,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex28) ).

fof(initSateConstraint_674,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex29) ).

fof(initSateConstraint_673,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex30) ).

fof(initSateConstraint_672,axiom,
    ~ v4933_array(constB0,b01110_address_term,bitIndex31) ).

fof(initSateConstraint_671,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex0) ).

fof(initSateConstraint_670,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex1) ).

fof(initSateConstraint_669,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex2) ).

fof(initSateConstraint_668,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex3) ).

fof(initSateConstraint_667,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex4) ).

fof(initSateConstraint_666,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex5) ).

fof(initSateConstraint_665,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex6) ).

fof(initSateConstraint_664,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex7) ).

fof(initSateConstraint_663,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex8) ).

fof(initSateConstraint_662,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex9) ).

fof(initSateConstraint_661,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex10) ).

fof(initSateConstraint_660,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex11) ).

fof(initSateConstraint_659,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex12) ).

fof(initSateConstraint_658,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex13) ).

fof(initSateConstraint_657,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex14) ).

fof(initSateConstraint_656,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex15) ).

fof(initSateConstraint_655,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex16) ).

fof(initSateConstraint_654,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex17) ).

fof(initSateConstraint_653,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex18) ).

fof(initSateConstraint_652,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex19) ).

fof(initSateConstraint_651,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex20) ).

fof(initSateConstraint_650,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex21) ).

fof(initSateConstraint_649,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex22) ).

fof(initSateConstraint_648,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex23) ).

fof(initSateConstraint_647,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex24) ).

fof(initSateConstraint_646,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex25) ).

fof(initSateConstraint_645,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex26) ).

fof(initSateConstraint_644,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex27) ).

fof(initSateConstraint_643,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex28) ).

fof(initSateConstraint_642,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex29) ).

fof(initSateConstraint_641,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex30) ).

fof(initSateConstraint_640,axiom,
    ~ v4933_array(constB0,b01101_address_term,bitIndex31) ).

fof(initSateConstraint_639,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex0) ).

fof(initSateConstraint_638,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex1) ).

fof(initSateConstraint_637,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex2) ).

fof(initSateConstraint_636,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex3) ).

fof(initSateConstraint_635,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex4) ).

fof(initSateConstraint_634,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex5) ).

fof(initSateConstraint_633,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex6) ).

fof(initSateConstraint_632,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex7) ).

fof(initSateConstraint_631,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex8) ).

fof(initSateConstraint_630,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex9) ).

fof(initSateConstraint_629,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex10) ).

fof(initSateConstraint_628,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex11) ).

fof(initSateConstraint_627,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex12) ).

fof(initSateConstraint_626,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex13) ).

fof(initSateConstraint_625,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex14) ).

fof(initSateConstraint_624,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex15) ).

fof(initSateConstraint_623,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex16) ).

fof(initSateConstraint_622,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex17) ).

fof(initSateConstraint_621,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex18) ).

fof(initSateConstraint_620,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex19) ).

fof(initSateConstraint_619,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex20) ).

fof(initSateConstraint_618,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex21) ).

fof(initSateConstraint_617,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex22) ).

fof(initSateConstraint_616,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex23) ).

fof(initSateConstraint_615,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex24) ).

fof(initSateConstraint_614,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex25) ).

fof(initSateConstraint_613,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex26) ).

fof(initSateConstraint_612,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex27) ).

fof(initSateConstraint_611,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex28) ).

fof(initSateConstraint_610,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex29) ).

fof(initSateConstraint_609,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex30) ).

fof(initSateConstraint_608,axiom,
    ~ v4933_array(constB0,b01100_address_term,bitIndex31) ).

fof(initSateConstraint_607,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex0) ).

fof(initSateConstraint_606,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex1) ).

fof(initSateConstraint_605,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex2) ).

fof(initSateConstraint_604,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex3) ).

fof(initSateConstraint_603,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex4) ).

fof(initSateConstraint_602,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex5) ).

fof(initSateConstraint_601,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex6) ).

fof(initSateConstraint_600,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex7) ).

fof(initSateConstraint_599,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex8) ).

fof(initSateConstraint_598,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex9) ).

fof(initSateConstraint_597,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex10) ).

fof(initSateConstraint_596,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex11) ).

fof(initSateConstraint_595,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex12) ).

fof(initSateConstraint_594,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex13) ).

fof(initSateConstraint_593,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex14) ).

fof(initSateConstraint_592,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex15) ).

fof(initSateConstraint_591,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex16) ).

fof(initSateConstraint_590,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex17) ).

fof(initSateConstraint_589,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex18) ).

fof(initSateConstraint_588,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex19) ).

fof(initSateConstraint_587,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex20) ).

fof(initSateConstraint_586,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex21) ).

fof(initSateConstraint_585,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex22) ).

fof(initSateConstraint_584,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex23) ).

fof(initSateConstraint_583,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex24) ).

fof(initSateConstraint_582,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex25) ).

fof(initSateConstraint_581,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex26) ).

fof(initSateConstraint_580,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex27) ).

fof(initSateConstraint_579,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex28) ).

fof(initSateConstraint_578,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex29) ).

fof(initSateConstraint_577,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex30) ).

fof(initSateConstraint_576,axiom,
    ~ v4933_array(constB0,b01011_address_term,bitIndex31) ).

fof(initSateConstraint_575,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex0) ).

fof(initSateConstraint_574,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex1) ).

fof(initSateConstraint_573,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex2) ).

fof(initSateConstraint_572,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex3) ).

fof(initSateConstraint_571,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex4) ).

fof(initSateConstraint_570,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex5) ).

fof(initSateConstraint_569,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex6) ).

fof(initSateConstraint_568,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex7) ).

fof(initSateConstraint_567,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex8) ).

fof(initSateConstraint_566,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex9) ).

fof(initSateConstraint_565,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex10) ).

fof(initSateConstraint_564,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex11) ).

fof(initSateConstraint_563,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex12) ).

fof(initSateConstraint_562,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex13) ).

fof(initSateConstraint_561,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex14) ).

fof(initSateConstraint_560,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex15) ).

fof(initSateConstraint_559,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex16) ).

fof(initSateConstraint_558,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex17) ).

fof(initSateConstraint_557,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex18) ).

fof(initSateConstraint_556,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex19) ).

fof(initSateConstraint_555,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex20) ).

fof(initSateConstraint_554,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex21) ).

fof(initSateConstraint_553,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex22) ).

fof(initSateConstraint_552,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex23) ).

fof(initSateConstraint_551,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex24) ).

fof(initSateConstraint_550,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex25) ).

fof(initSateConstraint_549,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex26) ).

fof(initSateConstraint_548,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex27) ).

fof(initSateConstraint_547,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex28) ).

fof(initSateConstraint_546,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex29) ).

fof(initSateConstraint_545,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex30) ).

fof(initSateConstraint_544,axiom,
    ~ v4933_array(constB0,b01010_address_term,bitIndex31) ).

fof(initSateConstraint_543,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex0) ).

fof(initSateConstraint_542,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex1) ).

fof(initSateConstraint_541,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex2) ).

fof(initSateConstraint_540,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex3) ).

fof(initSateConstraint_539,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex4) ).

fof(initSateConstraint_538,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex5) ).

fof(initSateConstraint_537,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex6) ).

fof(initSateConstraint_536,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex7) ).

fof(initSateConstraint_535,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex8) ).

fof(initSateConstraint_534,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex9) ).

fof(initSateConstraint_533,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex10) ).

fof(initSateConstraint_532,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex11) ).

fof(initSateConstraint_531,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex12) ).

fof(initSateConstraint_530,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex13) ).

fof(initSateConstraint_529,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex14) ).

fof(initSateConstraint_528,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex15) ).

fof(initSateConstraint_527,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex16) ).

fof(initSateConstraint_526,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex17) ).

fof(initSateConstraint_525,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex18) ).

fof(initSateConstraint_524,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex19) ).

fof(initSateConstraint_523,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex20) ).

fof(initSateConstraint_522,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex21) ).

fof(initSateConstraint_521,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex22) ).

fof(initSateConstraint_520,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex23) ).

fof(initSateConstraint_519,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex24) ).

fof(initSateConstraint_518,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex25) ).

fof(initSateConstraint_517,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex26) ).

fof(initSateConstraint_516,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex27) ).

fof(initSateConstraint_515,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex28) ).

fof(initSateConstraint_514,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex29) ).

fof(initSateConstraint_513,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex30) ).

fof(initSateConstraint_512,axiom,
    ~ v4933_array(constB0,b01001_address_term,bitIndex31) ).

fof(initSateConstraint_511,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex0) ).

fof(initSateConstraint_510,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex1) ).

fof(initSateConstraint_509,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex2) ).

fof(initSateConstraint_508,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex3) ).

fof(initSateConstraint_507,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex4) ).

fof(initSateConstraint_506,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex5) ).

fof(initSateConstraint_505,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex6) ).

fof(initSateConstraint_504,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex7) ).

fof(initSateConstraint_503,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex8) ).

fof(initSateConstraint_502,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex9) ).

fof(initSateConstraint_501,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex10) ).

fof(initSateConstraint_500,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex11) ).

fof(initSateConstraint_499,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex12) ).

fof(initSateConstraint_498,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex13) ).

fof(initSateConstraint_497,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex14) ).

fof(initSateConstraint_496,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex15) ).

fof(initSateConstraint_495,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex16) ).

fof(initSateConstraint_494,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex17) ).

fof(initSateConstraint_493,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex18) ).

fof(initSateConstraint_492,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex19) ).

fof(initSateConstraint_491,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex20) ).

fof(initSateConstraint_490,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex21) ).

fof(initSateConstraint_489,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex22) ).

fof(initSateConstraint_488,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex23) ).

fof(initSateConstraint_487,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex24) ).

fof(initSateConstraint_486,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex25) ).

fof(initSateConstraint_485,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex26) ).

fof(initSateConstraint_484,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex27) ).

fof(initSateConstraint_483,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex28) ).

fof(initSateConstraint_482,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex29) ).

fof(initSateConstraint_481,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex30) ).

fof(initSateConstraint_480,axiom,
    ~ v4933_array(constB0,b01000_address_term,bitIndex31) ).

fof(initSateConstraint_479,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex0) ).

fof(initSateConstraint_478,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex1) ).

fof(initSateConstraint_477,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex2) ).

fof(initSateConstraint_476,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex3) ).

fof(initSateConstraint_475,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex4) ).

fof(initSateConstraint_474,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex5) ).

fof(initSateConstraint_473,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex6) ).

fof(initSateConstraint_472,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex7) ).

fof(initSateConstraint_471,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex8) ).

fof(initSateConstraint_470,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex9) ).

fof(initSateConstraint_469,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex10) ).

fof(initSateConstraint_468,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex11) ).

fof(initSateConstraint_467,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex12) ).

fof(initSateConstraint_466,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex13) ).

fof(initSateConstraint_465,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex14) ).

fof(initSateConstraint_464,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex15) ).

fof(initSateConstraint_463,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex16) ).

fof(initSateConstraint_462,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex17) ).

fof(initSateConstraint_461,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex18) ).

fof(initSateConstraint_460,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex19) ).

fof(initSateConstraint_459,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex20) ).

fof(initSateConstraint_458,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex21) ).

fof(initSateConstraint_457,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex22) ).

fof(initSateConstraint_456,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex23) ).

fof(initSateConstraint_455,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex24) ).

fof(initSateConstraint_454,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex25) ).

fof(initSateConstraint_453,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex26) ).

fof(initSateConstraint_452,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex27) ).

fof(initSateConstraint_451,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex28) ).

fof(initSateConstraint_450,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex29) ).

fof(initSateConstraint_449,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex30) ).

fof(initSateConstraint_448,axiom,
    ~ v4933_array(constB0,b00111_address_term,bitIndex31) ).

fof(initSateConstraint_447,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex0) ).

fof(initSateConstraint_446,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex1) ).

fof(initSateConstraint_445,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex2) ).

fof(initSateConstraint_444,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex3) ).

fof(initSateConstraint_443,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex4) ).

fof(initSateConstraint_442,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex5) ).

fof(initSateConstraint_441,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex6) ).

fof(initSateConstraint_440,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex7) ).

fof(initSateConstraint_439,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex8) ).

fof(initSateConstraint_438,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex9) ).

fof(initSateConstraint_437,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex10) ).

fof(initSateConstraint_436,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex11) ).

fof(initSateConstraint_435,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex12) ).

fof(initSateConstraint_434,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex13) ).

fof(initSateConstraint_433,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex14) ).

fof(initSateConstraint_432,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex15) ).

fof(initSateConstraint_431,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex16) ).

fof(initSateConstraint_430,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex17) ).

fof(initSateConstraint_429,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex18) ).

fof(initSateConstraint_428,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex19) ).

fof(initSateConstraint_427,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex20) ).

fof(initSateConstraint_426,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex21) ).

fof(initSateConstraint_425,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex22) ).

fof(initSateConstraint_424,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex23) ).

fof(initSateConstraint_423,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex24) ).

fof(initSateConstraint_422,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex25) ).

fof(initSateConstraint_421,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex26) ).

fof(initSateConstraint_420,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex27) ).

fof(initSateConstraint_419,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex28) ).

fof(initSateConstraint_418,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex29) ).

fof(initSateConstraint_417,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex30) ).

fof(initSateConstraint_416,axiom,
    ~ v4933_array(constB0,b00110_address_term,bitIndex31) ).

fof(initSateConstraint_415,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex0) ).

fof(initSateConstraint_414,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex1) ).

fof(initSateConstraint_413,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex2) ).

fof(initSateConstraint_412,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex3) ).

fof(initSateConstraint_411,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex4) ).

fof(initSateConstraint_410,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex5) ).

fof(initSateConstraint_409,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex6) ).

fof(initSateConstraint_408,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex7) ).

fof(initSateConstraint_407,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex8) ).

fof(initSateConstraint_406,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex9) ).

fof(initSateConstraint_405,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex10) ).

fof(initSateConstraint_404,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex11) ).

fof(initSateConstraint_403,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex12) ).

fof(initSateConstraint_402,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex13) ).

fof(initSateConstraint_401,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex14) ).

fof(initSateConstraint_400,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex15) ).

fof(initSateConstraint_399,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex16) ).

fof(initSateConstraint_398,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex17) ).

fof(initSateConstraint_397,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex18) ).

fof(initSateConstraint_396,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex19) ).

fof(initSateConstraint_395,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex20) ).

fof(initSateConstraint_394,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex21) ).

fof(initSateConstraint_393,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex22) ).

fof(initSateConstraint_392,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex23) ).

fof(initSateConstraint_391,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex24) ).

fof(initSateConstraint_390,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex25) ).

fof(initSateConstraint_389,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex26) ).

fof(initSateConstraint_388,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex27) ).

fof(initSateConstraint_387,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex28) ).

fof(initSateConstraint_386,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex29) ).

fof(initSateConstraint_385,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex30) ).

fof(initSateConstraint_384,axiom,
    ~ v4933_array(constB0,b00101_address_term,bitIndex31) ).

fof(initSateConstraint_383,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex0) ).

fof(initSateConstraint_382,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex1) ).

fof(initSateConstraint_381,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex2) ).

fof(initSateConstraint_380,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex3) ).

fof(initSateConstraint_379,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex4) ).

fof(initSateConstraint_378,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex5) ).

fof(initSateConstraint_377,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex6) ).

fof(initSateConstraint_376,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex7) ).

fof(initSateConstraint_375,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex8) ).

fof(initSateConstraint_374,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex9) ).

fof(initSateConstraint_373,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex10) ).

fof(initSateConstraint_372,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex11) ).

fof(initSateConstraint_371,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex12) ).

fof(initSateConstraint_370,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex13) ).

fof(initSateConstraint_369,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex14) ).

fof(initSateConstraint_368,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex15) ).

fof(initSateConstraint_367,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex16) ).

fof(initSateConstraint_366,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex17) ).

fof(initSateConstraint_365,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex18) ).

fof(initSateConstraint_364,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex19) ).

fof(initSateConstraint_363,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex20) ).

fof(initSateConstraint_362,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex21) ).

fof(initSateConstraint_361,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex22) ).

fof(initSateConstraint_360,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex23) ).

fof(initSateConstraint_359,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex24) ).

fof(initSateConstraint_358,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex25) ).

fof(initSateConstraint_357,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex26) ).

fof(initSateConstraint_356,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex27) ).

fof(initSateConstraint_355,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex28) ).

fof(initSateConstraint_354,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex29) ).

fof(initSateConstraint_353,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex30) ).

fof(initSateConstraint_352,axiom,
    ~ v4933_array(constB0,b00100_address_term,bitIndex31) ).

fof(initSateConstraint_351,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex0) ).

fof(initSateConstraint_350,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex1) ).

fof(initSateConstraint_349,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex2) ).

fof(initSateConstraint_348,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex3) ).

fof(initSateConstraint_347,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex4) ).

fof(initSateConstraint_346,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex5) ).

fof(initSateConstraint_345,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex6) ).

fof(initSateConstraint_344,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex7) ).

fof(initSateConstraint_343,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex8) ).

fof(initSateConstraint_342,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex9) ).

fof(initSateConstraint_341,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex10) ).

fof(initSateConstraint_340,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex11) ).

fof(initSateConstraint_339,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex12) ).

fof(initSateConstraint_338,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex13) ).

fof(initSateConstraint_337,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex14) ).

fof(initSateConstraint_336,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex15) ).

fof(initSateConstraint_335,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex16) ).

fof(initSateConstraint_334,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex17) ).

fof(initSateConstraint_333,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex18) ).

fof(initSateConstraint_332,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex19) ).

fof(initSateConstraint_331,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex20) ).

fof(initSateConstraint_330,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex21) ).

fof(initSateConstraint_329,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex22) ).

fof(initSateConstraint_328,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex23) ).

fof(initSateConstraint_327,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex24) ).

fof(initSateConstraint_326,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex25) ).

fof(initSateConstraint_325,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex26) ).

fof(initSateConstraint_324,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex27) ).

fof(initSateConstraint_323,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex28) ).

fof(initSateConstraint_322,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex29) ).

fof(initSateConstraint_321,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex30) ).

fof(initSateConstraint_320,axiom,
    ~ v4933_array(constB0,b00011_address_term,bitIndex31) ).

fof(initSateConstraint_319,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex0) ).

fof(initSateConstraint_318,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex1) ).

fof(initSateConstraint_317,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex2) ).

fof(initSateConstraint_316,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex3) ).

fof(initSateConstraint_315,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex4) ).

fof(initSateConstraint_314,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex5) ).

fof(initSateConstraint_313,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex6) ).

fof(initSateConstraint_312,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex7) ).

fof(initSateConstraint_311,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex8) ).

fof(initSateConstraint_310,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex9) ).

fof(initSateConstraint_309,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex10) ).

fof(initSateConstraint_308,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex11) ).

fof(initSateConstraint_307,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex12) ).

fof(initSateConstraint_306,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex13) ).

fof(initSateConstraint_305,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex14) ).

fof(initSateConstraint_304,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex15) ).

fof(initSateConstraint_303,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex16) ).

fof(initSateConstraint_302,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex17) ).

fof(initSateConstraint_301,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex18) ).

fof(initSateConstraint_300,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex19) ).

fof(initSateConstraint_299,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex20) ).

fof(initSateConstraint_298,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex21) ).

fof(initSateConstraint_297,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex22) ).

fof(initSateConstraint_296,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex23) ).

fof(initSateConstraint_295,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex24) ).

fof(initSateConstraint_294,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex25) ).

fof(initSateConstraint_293,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex26) ).

fof(initSateConstraint_292,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex27) ).

fof(initSateConstraint_291,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex28) ).

fof(initSateConstraint_290,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex29) ).

fof(initSateConstraint_289,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex30) ).

fof(initSateConstraint_288,axiom,
    ~ v4933_array(constB0,b00010_address_term,bitIndex31) ).

fof(initSateConstraint_287,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex0) ).

fof(initSateConstraint_286,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex1) ).

fof(initSateConstraint_285,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex2) ).

fof(initSateConstraint_284,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex3) ).

fof(initSateConstraint_283,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex4) ).

fof(initSateConstraint_282,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex5) ).

fof(initSateConstraint_281,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex6) ).

fof(initSateConstraint_280,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex7) ).

fof(initSateConstraint_279,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex8) ).

fof(initSateConstraint_278,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex9) ).

fof(initSateConstraint_277,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex10) ).

fof(initSateConstraint_276,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex11) ).

fof(initSateConstraint_275,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex12) ).

fof(initSateConstraint_274,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex13) ).

fof(initSateConstraint_273,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex14) ).

fof(initSateConstraint_272,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex15) ).

fof(initSateConstraint_271,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex16) ).

fof(initSateConstraint_270,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex17) ).

fof(initSateConstraint_269,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex18) ).

fof(initSateConstraint_268,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex19) ).

fof(initSateConstraint_267,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex20) ).

fof(initSateConstraint_266,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex21) ).

fof(initSateConstraint_265,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex22) ).

fof(initSateConstraint_264,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex23) ).

fof(initSateConstraint_263,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex24) ).

fof(initSateConstraint_262,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex25) ).

fof(initSateConstraint_261,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex26) ).

fof(initSateConstraint_260,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex27) ).

fof(initSateConstraint_259,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex28) ).

fof(initSateConstraint_258,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex29) ).

fof(initSateConstraint_257,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex30) ).

fof(initSateConstraint_256,axiom,
    ~ v4933_array(constB0,b00001_address_term,bitIndex31) ).

fof(initSateConstraint_255,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex0) ).

fof(initSateConstraint_254,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex1) ).

fof(initSateConstraint_253,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex2) ).

fof(initSateConstraint_252,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex3) ).

fof(initSateConstraint_251,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex4) ).

fof(initSateConstraint_250,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex5) ).

fof(initSateConstraint_249,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex6) ).

fof(initSateConstraint_248,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex7) ).

fof(initSateConstraint_247,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex8) ).

fof(initSateConstraint_246,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex9) ).

fof(initSateConstraint_245,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex10) ).

fof(initSateConstraint_244,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex11) ).

fof(initSateConstraint_243,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex12) ).

fof(initSateConstraint_242,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex13) ).

fof(initSateConstraint_241,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex14) ).

fof(initSateConstraint_240,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex15) ).

fof(initSateConstraint_239,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex16) ).

fof(initSateConstraint_238,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex17) ).

fof(initSateConstraint_237,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex18) ).

fof(initSateConstraint_236,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex19) ).

fof(initSateConstraint_235,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex20) ).

fof(initSateConstraint_234,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex21) ).

fof(initSateConstraint_233,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex22) ).

fof(initSateConstraint_232,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex23) ).

fof(initSateConstraint_231,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex24) ).

fof(initSateConstraint_230,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex25) ).

fof(initSateConstraint_229,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex26) ).

fof(initSateConstraint_228,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex27) ).

fof(initSateConstraint_227,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex28) ).

fof(initSateConstraint_226,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex29) ).

fof(initSateConstraint_225,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex30) ).

fof(initSateConstraint_224,axiom,
    ~ v4933_array(constB0,b00000_address_term,bitIndex31) ).

fof(addAssignment_1776,axiom,
    ! [VarCurr,B] :
      ( range_43_0(B)
     => ( v6273(VarCurr,B)
      <=> v6275(VarCurr,B) ) ) ).

fof(addAssignment_1775,axiom,
    ! [VarCurr,B] :
      ( range_43_0(B)
     => ( v6275(VarCurr,B)
      <=> v6277(VarCurr,B) ) ) ).

fof(addAssignment_1774,axiom,
    ! [VarCurr,B] :
      ( range_43_0(B)
     => ( v6277(VarCurr,B)
      <=> v6279(VarCurr,B) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_122,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7248(VarNext)
       => ! [B] :
            ( range_43_0(B)
           => ( v6279(VarNext,B)
            <=> v6279(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_131,axiom,
    ! [VarNext] :
      ( v7248(VarNext)
     => ! [B] :
          ( range_43_0(B)
         => ( v6279(VarNext,B)
          <=> v7259(VarNext,B) ) ) ) ).

fof(addAssignment_1773,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_43_0(B)
         => ( v7259(VarNext,B)
          <=> v7257(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_183,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ! [B] :
          ( range_43_0(B)
         => ( v7257(VarCurr,B)
          <=> v7260(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_185,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ! [B] :
          ( range_43_0(B)
         => ( v7257(VarCurr,B)
          <=> $false ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_182,axiom,
    ! [VarCurr] :
      ( ~ v3182(VarCurr)
     => ! [B] :
          ( range_43_0(B)
         => ( v7260(VarCurr,B)
          <=> v7263(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_184,axiom,
    ! [VarCurr] :
      ( v3182(VarCurr)
     => ! [B] :
          ( range_43_0(B)
         => ( v7260(VarCurr,B)
          <=> v7261(VarCurr,B) ) ) ) ).

fof(addAssignment_1772,axiom,
    ! [VarCurr,B] :
      ( range_31_0(B)
     => ( v7263(VarCurr,B)
      <=> v7170(VarCurr,B) ) ) ).

fof(addAssignment_1771,axiom,
    ! [VarCurr,B] :
      ( range_43_32(B)
     => ( v7263(VarCurr,B)
      <=> v5625(VarCurr,B) ) ) ).

fof(addAssignment_1770,axiom,
    ! [VarCurr,B] :
      ( range_31_0(B)
     => ( v7261(VarCurr,B)
      <=> v7262(VarCurr,B) ) ) ).

fof(addAssignment_1769,axiom,
    ! [VarCurr,B] :
      ( range_43_32(B)
     => ( v7261(VarCurr,B)
      <=> v5625(VarCurr,B) ) ) ).

fof(writeBinaryOperatorEqualRangesMultipleBits_8,axiom,
    ! [VarCurr,B] :
      ( range_31_0(B)
     => ( v7262(VarCurr,B)
      <=> ( v6549(VarCurr,B)
          & v4923(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1295,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7248(VarNext)
      <=> ( v7249(VarNext)
          & v7256(VarNext) ) ) ) ).

fof(addAssignment_1768,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7256(VarNext)
      <=> v7254(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1294,axiom,
    ! [VarCurr] :
      ( v7254(VarCurr)
    <=> ( v5278(VarCurr)
        | v5397(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1293,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7249(VarNext)
      <=> ( v7251(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_608,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7251(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValue_108,axiom,
    ~ v6279(constB0,bitIndex31) ).

fof(addAssignmentInitValue_107,axiom,
    ~ v6279(constB0,bitIndex30) ).

fof(addAssignmentInitValue_106,axiom,
    ~ v6279(constB0,bitIndex29) ).

fof(addAssignmentInitValue_105,axiom,
    ~ v6279(constB0,bitIndex28) ).

fof(addAssignmentInitValue_104,axiom,
    ~ v6279(constB0,bitIndex27) ).

fof(addAssignmentInitValue_103,axiom,
    ~ v6279(constB0,bitIndex26) ).

fof(addAssignmentInitValue_102,axiom,
    ~ v6279(constB0,bitIndex25) ).

fof(addAssignmentInitValue_101,axiom,
    ~ v6279(constB0,bitIndex24) ).

fof(addAssignmentInitValue_100,axiom,
    ~ v6279(constB0,bitIndex23) ).

fof(addAssignmentInitValue_99,axiom,
    ~ v6279(constB0,bitIndex22) ).

fof(addAssignmentInitValue_98,axiom,
    ~ v6279(constB0,bitIndex21) ).

fof(addAssignmentInitValue_97,axiom,
    ~ v6279(constB0,bitIndex20) ).

fof(addAssignmentInitValue_96,axiom,
    ~ v6279(constB0,bitIndex19) ).

fof(addAssignmentInitValue_95,axiom,
    ~ v6279(constB0,bitIndex18) ).

fof(addAssignmentInitValue_94,axiom,
    ~ v6279(constB0,bitIndex17) ).

fof(addAssignmentInitValue_93,axiom,
    ~ v6279(constB0,bitIndex16) ).

fof(addAssignmentInitValue_92,axiom,
    ~ v6279(constB0,bitIndex15) ).

fof(addAssignmentInitValue_91,axiom,
    ~ v6279(constB0,bitIndex14) ).

fof(addAssignmentInitValue_90,axiom,
    ~ v6279(constB0,bitIndex13) ).

fof(addAssignmentInitValue_89,axiom,
    ~ v6279(constB0,bitIndex12) ).

fof(addAssignmentInitValue_88,axiom,
    ~ v6279(constB0,bitIndex11) ).

fof(addAssignmentInitValue_87,axiom,
    ~ v6279(constB0,bitIndex10) ).

fof(addAssignmentInitValue_86,axiom,
    ~ v6279(constB0,bitIndex9) ).

fof(addAssignmentInitValue_85,axiom,
    ~ v6279(constB0,bitIndex8) ).

fof(addAssignmentInitValue_84,axiom,
    ~ v6279(constB0,bitIndex7) ).

fof(addAssignmentInitValue_83,axiom,
    ~ v6279(constB0,bitIndex6) ).

fof(addAssignmentInitValue_82,axiom,
    ~ v6279(constB0,bitIndex5) ).

fof(addAssignmentInitValue_81,axiom,
    ~ v6279(constB0,bitIndex4) ).

fof(addAssignmentInitValue_80,axiom,
    ~ v6279(constB0,bitIndex3) ).

fof(addAssignmentInitValue_79,axiom,
    ~ v6279(constB0,bitIndex2) ).

fof(addAssignmentInitValue_78,axiom,
    ~ v6279(constB0,bitIndex1) ).

fof(addAssignmentInitValue_77,axiom,
    ~ v6279(constB0,bitIndex0) ).

fof(bitBlastConstant_787,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex31) ).

fof(bitBlastConstant_786,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex30) ).

fof(bitBlastConstant_785,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex29) ).

fof(bitBlastConstant_784,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex28) ).

fof(bitBlastConstant_783,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex27) ).

fof(bitBlastConstant_782,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex26) ).

fof(bitBlastConstant_781,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex25) ).

fof(bitBlastConstant_780,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex24) ).

fof(bitBlastConstant_779,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex23) ).

fof(bitBlastConstant_778,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex22) ).

fof(bitBlastConstant_777,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex21) ).

fof(bitBlastConstant_776,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex20) ).

fof(bitBlastConstant_775,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex19) ).

fof(bitBlastConstant_774,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex18) ).

fof(bitBlastConstant_773,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex17) ).

fof(bitBlastConstant_772,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex16) ).

fof(bitBlastConstant_771,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex15) ).

fof(bitBlastConstant_770,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex14) ).

fof(bitBlastConstant_769,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex13) ).

fof(bitBlastConstant_768,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex12) ).

fof(bitBlastConstant_767,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex11) ).

fof(bitBlastConstant_766,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex10) ).

fof(bitBlastConstant_765,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex9) ).

fof(bitBlastConstant_764,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex8) ).

fof(bitBlastConstant_763,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex7) ).

fof(bitBlastConstant_762,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex6) ).

fof(bitBlastConstant_761,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex5) ).

fof(bitBlastConstant_760,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex4) ).

fof(bitBlastConstant_759,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex3) ).

fof(bitBlastConstant_758,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex2) ).

fof(bitBlastConstant_757,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex1) ).

fof(bitBlastConstant_756,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex0) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_181,axiom,
    ! [VarCurr] :
      ( ~ v7238(VarCurr)
     => ! [B] :
          ( range_31_0(B)
         => ( v7170(VarCurr,B)
          <=> v4923(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_183,axiom,
    ! [VarCurr] :
      ( v7238(VarCurr)
     => ! [B] :
          ( range_31_0(B)
         => ( v7170(VarCurr,B)
          <=> v7243(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesMultipleBits_7,axiom,
    ! [VarCurr,B] :
      ( range_31_0(B)
     => ( v7243(VarCurr,B)
      <=> ( v7172(VarCurr,B)
          & v4923(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1292,axiom,
    ! [VarCurr] :
      ( v7238(VarCurr)
    <=> ( v7239(VarCurr)
        & v7242(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_475,axiom,
    ! [VarCurr] :
      ( v7242(VarCurr)
    <=> ( v4697(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1291,axiom,
    ! [VarCurr] :
      ( v7239(VarCurr)
    <=> ( v7240(VarCurr)
        | v7241(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_474,axiom,
    ! [VarCurr] :
      ( v7241(VarCurr)
    <=> ( ( v4672(VarCurr,bitIndex2)
        <=> $false )
        & ( v4672(VarCurr,bitIndex1)
        <=> $false )
        & ( v4672(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_473,axiom,
    ! [VarCurr] :
      ( v7240(VarCurr)
    <=> ( ( v4672(VarCurr,bitIndex2)
        <=> $false )
        & ( v4672(VarCurr,bitIndex1)
        <=> $true )
        & ( v4672(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_107,axiom,
    ! [VarCurr] :
      ( ~ v7236(VarCurr)
     => ( v7172(VarCurr,bitIndex31)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_105,axiom,
    ! [VarCurr] :
      ( v7236(VarCurr)
     => ( v7172(VarCurr,bitIndex31)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_472,axiom,
    ! [VarCurr] :
      ( v7236(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_106,axiom,
    ! [VarCurr] :
      ( ~ v7234(VarCurr)
     => ( v7172(VarCurr,bitIndex30)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_104,axiom,
    ! [VarCurr] :
      ( v7234(VarCurr)
     => ( v7172(VarCurr,bitIndex30)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_471,axiom,
    ! [VarCurr] :
      ( v7234(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_105,axiom,
    ! [VarCurr] :
      ( ~ v7232(VarCurr)
     => ( v7172(VarCurr,bitIndex29)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_103,axiom,
    ! [VarCurr] :
      ( v7232(VarCurr)
     => ( v7172(VarCurr,bitIndex29)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_470,axiom,
    ! [VarCurr] :
      ( v7232(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_104,axiom,
    ! [VarCurr] :
      ( ~ v7230(VarCurr)
     => ( v7172(VarCurr,bitIndex28)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_102,axiom,
    ! [VarCurr] :
      ( v7230(VarCurr)
     => ( v7172(VarCurr,bitIndex28)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_469,axiom,
    ! [VarCurr] :
      ( v7230(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_103,axiom,
    ! [VarCurr] :
      ( ~ v7228(VarCurr)
     => ( v7172(VarCurr,bitIndex27)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_101,axiom,
    ! [VarCurr] :
      ( v7228(VarCurr)
     => ( v7172(VarCurr,bitIndex27)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_468,axiom,
    ! [VarCurr] :
      ( v7228(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_102,axiom,
    ! [VarCurr] :
      ( ~ v7226(VarCurr)
     => ( v7172(VarCurr,bitIndex26)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_100,axiom,
    ! [VarCurr] :
      ( v7226(VarCurr)
     => ( v7172(VarCurr,bitIndex26)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_467,axiom,
    ! [VarCurr] :
      ( v7226(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_101,axiom,
    ! [VarCurr] :
      ( ~ v7224(VarCurr)
     => ( v7172(VarCurr,bitIndex25)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_99,axiom,
    ! [VarCurr] :
      ( v7224(VarCurr)
     => ( v7172(VarCurr,bitIndex25)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_466,axiom,
    ! [VarCurr] :
      ( v7224(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_100,axiom,
    ! [VarCurr] :
      ( ~ v7222(VarCurr)
     => ( v7172(VarCurr,bitIndex24)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_98,axiom,
    ! [VarCurr] :
      ( v7222(VarCurr)
     => ( v7172(VarCurr,bitIndex24)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_465,axiom,
    ! [VarCurr] :
      ( v7222(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_99,axiom,
    ! [VarCurr] :
      ( ~ v7220(VarCurr)
     => ( v7172(VarCurr,bitIndex23)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_97,axiom,
    ! [VarCurr] :
      ( v7220(VarCurr)
     => ( v7172(VarCurr,bitIndex23)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_464,axiom,
    ! [VarCurr] :
      ( v7220(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_98,axiom,
    ! [VarCurr] :
      ( ~ v7218(VarCurr)
     => ( v7172(VarCurr,bitIndex22)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_96,axiom,
    ! [VarCurr] :
      ( v7218(VarCurr)
     => ( v7172(VarCurr,bitIndex22)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_463,axiom,
    ! [VarCurr] :
      ( v7218(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_97,axiom,
    ! [VarCurr] :
      ( ~ v7216(VarCurr)
     => ( v7172(VarCurr,bitIndex21)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_95,axiom,
    ! [VarCurr] :
      ( v7216(VarCurr)
     => ( v7172(VarCurr,bitIndex21)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_462,axiom,
    ! [VarCurr] :
      ( v7216(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_96,axiom,
    ! [VarCurr] :
      ( ~ v7214(VarCurr)
     => ( v7172(VarCurr,bitIndex20)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_94,axiom,
    ! [VarCurr] :
      ( v7214(VarCurr)
     => ( v7172(VarCurr,bitIndex20)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_461,axiom,
    ! [VarCurr] :
      ( v7214(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_95,axiom,
    ! [VarCurr] :
      ( ~ v7212(VarCurr)
     => ( v7172(VarCurr,bitIndex19)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_93,axiom,
    ! [VarCurr] :
      ( v7212(VarCurr)
     => ( v7172(VarCurr,bitIndex19)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_460,axiom,
    ! [VarCurr] :
      ( v7212(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_94,axiom,
    ! [VarCurr] :
      ( ~ v7210(VarCurr)
     => ( v7172(VarCurr,bitIndex18)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_92,axiom,
    ! [VarCurr] :
      ( v7210(VarCurr)
     => ( v7172(VarCurr,bitIndex18)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_459,axiom,
    ! [VarCurr] :
      ( v7210(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_93,axiom,
    ! [VarCurr] :
      ( ~ v7208(VarCurr)
     => ( v7172(VarCurr,bitIndex17)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_91,axiom,
    ! [VarCurr] :
      ( v7208(VarCurr)
     => ( v7172(VarCurr,bitIndex17)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_458,axiom,
    ! [VarCurr] :
      ( v7208(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_92,axiom,
    ! [VarCurr] :
      ( ~ v7206(VarCurr)
     => ( v7172(VarCurr,bitIndex16)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_90,axiom,
    ! [VarCurr] :
      ( v7206(VarCurr)
     => ( v7172(VarCurr,bitIndex16)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_457,axiom,
    ! [VarCurr] :
      ( v7206(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $true )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_91,axiom,
    ! [VarCurr] :
      ( ~ v7204(VarCurr)
     => ( v7172(VarCurr,bitIndex15)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_89,axiom,
    ! [VarCurr] :
      ( v7204(VarCurr)
     => ( v7172(VarCurr,bitIndex15)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_456,axiom,
    ! [VarCurr] :
      ( v7204(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_90,axiom,
    ! [VarCurr] :
      ( ~ v7202(VarCurr)
     => ( v7172(VarCurr,bitIndex14)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_88,axiom,
    ! [VarCurr] :
      ( v7202(VarCurr)
     => ( v7172(VarCurr,bitIndex14)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_455,axiom,
    ! [VarCurr] :
      ( v7202(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_89,axiom,
    ! [VarCurr] :
      ( ~ v7200(VarCurr)
     => ( v7172(VarCurr,bitIndex13)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_87,axiom,
    ! [VarCurr] :
      ( v7200(VarCurr)
     => ( v7172(VarCurr,bitIndex13)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_454,axiom,
    ! [VarCurr] :
      ( v7200(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_88,axiom,
    ! [VarCurr] :
      ( ~ v7198(VarCurr)
     => ( v7172(VarCurr,bitIndex12)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_86,axiom,
    ! [VarCurr] :
      ( v7198(VarCurr)
     => ( v7172(VarCurr,bitIndex12)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_453,axiom,
    ! [VarCurr] :
      ( v7198(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_87,axiom,
    ! [VarCurr] :
      ( ~ v7196(VarCurr)
     => ( v7172(VarCurr,bitIndex11)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_85,axiom,
    ! [VarCurr] :
      ( v7196(VarCurr)
     => ( v7172(VarCurr,bitIndex11)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_452,axiom,
    ! [VarCurr] :
      ( v7196(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_86,axiom,
    ! [VarCurr] :
      ( ~ v7194(VarCurr)
     => ( v7172(VarCurr,bitIndex10)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_84,axiom,
    ! [VarCurr] :
      ( v7194(VarCurr)
     => ( v7172(VarCurr,bitIndex10)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_451,axiom,
    ! [VarCurr] :
      ( v7194(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_85,axiom,
    ! [VarCurr] :
      ( ~ v7192(VarCurr)
     => ( v7172(VarCurr,bitIndex9)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_83,axiom,
    ! [VarCurr] :
      ( v7192(VarCurr)
     => ( v7172(VarCurr,bitIndex9)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_450,axiom,
    ! [VarCurr] :
      ( v7192(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_84,axiom,
    ! [VarCurr] :
      ( ~ v7190(VarCurr)
     => ( v7172(VarCurr,bitIndex8)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_82,axiom,
    ! [VarCurr] :
      ( v7190(VarCurr)
     => ( v7172(VarCurr,bitIndex8)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_449,axiom,
    ! [VarCurr] :
      ( v7190(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $true )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_83,axiom,
    ! [VarCurr] :
      ( ~ v7188(VarCurr)
     => ( v7172(VarCurr,bitIndex7)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_81,axiom,
    ! [VarCurr] :
      ( v7188(VarCurr)
     => ( v7172(VarCurr,bitIndex7)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_448,axiom,
    ! [VarCurr] :
      ( v7188(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_82,axiom,
    ! [VarCurr] :
      ( ~ v7186(VarCurr)
     => ( v7172(VarCurr,bitIndex6)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_80,axiom,
    ! [VarCurr] :
      ( v7186(VarCurr)
     => ( v7172(VarCurr,bitIndex6)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_447,axiom,
    ! [VarCurr] :
      ( v7186(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_81,axiom,
    ! [VarCurr] :
      ( ~ v7184(VarCurr)
     => ( v7172(VarCurr,bitIndex5)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_79,axiom,
    ! [VarCurr] :
      ( v7184(VarCurr)
     => ( v7172(VarCurr,bitIndex5)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_446,axiom,
    ! [VarCurr] :
      ( v7184(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_80,axiom,
    ! [VarCurr] :
      ( ~ v7182(VarCurr)
     => ( v7172(VarCurr,bitIndex4)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_78,axiom,
    ! [VarCurr] :
      ( v7182(VarCurr)
     => ( v7172(VarCurr,bitIndex4)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_445,axiom,
    ! [VarCurr] :
      ( v7182(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $true )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_79,axiom,
    ! [VarCurr] :
      ( ~ v7180(VarCurr)
     => ( v7172(VarCurr,bitIndex3)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_77,axiom,
    ! [VarCurr] :
      ( v7180(VarCurr)
     => ( v7172(VarCurr,bitIndex3)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_444,axiom,
    ! [VarCurr] :
      ( v7180(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_78,axiom,
    ! [VarCurr] :
      ( ~ v7178(VarCurr)
     => ( v7172(VarCurr,bitIndex2)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_76,axiom,
    ! [VarCurr] :
      ( v7178(VarCurr)
     => ( v7172(VarCurr,bitIndex2)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_443,axiom,
    ! [VarCurr] :
      ( v7178(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $true )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_77,axiom,
    ! [VarCurr] :
      ( ~ v7176(VarCurr)
     => ( v7172(VarCurr,bitIndex1)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_75,axiom,
    ! [VarCurr] :
      ( v7176(VarCurr)
     => ( v7172(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_442,axiom,
    ! [VarCurr] :
      ( v7176(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_180,axiom,
    ! [VarCurr] :
      ( ~ v7174(VarCurr)
     => ( v7172(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_182,axiom,
    ! [VarCurr] :
      ( v7174(VarCurr)
     => ( v7172(VarCurr,bitIndex0)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_441,axiom,
    ! [VarCurr] :
      ( v7174(VarCurr)
    <=> ( ( v4699(VarCurr,bitIndex4)
        <=> $false )
        & ( v4699(VarCurr,bitIndex3)
        <=> $false )
        & ( v4699(VarCurr,bitIndex2)
        <=> $false )
        & ( v4699(VarCurr,bitIndex1)
        <=> $false )
        & ( v4699(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1767,axiom,
    ! [VarCurr,B] :
      ( range_31_0(B)
     => ( v4923(VarCurr,B)
      <=> v4925(VarCurr,B) ) ) ).

fof(addAssignment_1766,axiom,
    ! [VarCurr,B] :
      ( range_31_1(B)
     => ( v4925(VarCurr,B)
      <=> v4927(VarCurr,B) ) ) ).

fof(addAssignment_1765,axiom,
    ! [VarCurr,B] :
      ( range_31_1(B)
     => ( v4927(VarCurr,B)
      <=> v4929(VarCurr,B) ) ) ).

fof(addAssignment_1764,axiom,
    ! [VarCurr,B] :
      ( range_31_1(B)
     => ( v4929(VarCurr,B)
      <=> v4931(VarCurr,B) ) ) ).

fof(addAssignment_1763,axiom,
    ! [VarCurr,B] :
      ( range_31_1(B)
     => ( v4931(VarCurr,B)
      <=> v6529(VarCurr,B) ) ) ).

fof(range_axiom_47,axiom,
    ! [B] :
      ( range_31_1(B)
    <=> ( $false
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B
        | bitIndex11 = B
        | bitIndex12 = B
        | bitIndex13 = B
        | bitIndex14 = B
        | bitIndex15 = B
        | bitIndex16 = B
        | bitIndex17 = B
        | bitIndex18 = B
        | bitIndex19 = B
        | bitIndex20 = B
        | bitIndex21 = B
        | bitIndex22 = B
        | bitIndex23 = B
        | bitIndex24 = B
        | bitIndex25 = B
        | bitIndex26 = B
        | bitIndex27 = B
        | bitIndex28 = B
        | bitIndex29 = B
        | bitIndex30 = B
        | bitIndex31 = B ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_76,axiom,
    ! [VarCurr] :
      ( ~ v7168(VarCurr)
     => ( v6549(VarCurr,bitIndex31)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_74,axiom,
    ! [VarCurr] :
      ( v7168(VarCurr)
     => ( v6549(VarCurr,bitIndex31)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_440,axiom,
    ! [VarCurr] :
      ( v7168(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_75,axiom,
    ! [VarCurr] :
      ( ~ v7166(VarCurr)
     => ( v6549(VarCurr,bitIndex30)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_73,axiom,
    ! [VarCurr] :
      ( v7166(VarCurr)
     => ( v6549(VarCurr,bitIndex30)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_439,axiom,
    ! [VarCurr] :
      ( v7166(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_755,axiom,
    b11110(bitIndex4) ).

fof(bitBlastConstant_754,axiom,
    b11110(bitIndex3) ).

fof(bitBlastConstant_753,axiom,
    b11110(bitIndex2) ).

fof(bitBlastConstant_752,axiom,
    b11110(bitIndex1) ).

fof(bitBlastConstant_751,axiom,
    ~ b11110(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_74,axiom,
    ! [VarCurr] :
      ( ~ v7164(VarCurr)
     => ( v6549(VarCurr,bitIndex29)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_72,axiom,
    ! [VarCurr] :
      ( v7164(VarCurr)
     => ( v6549(VarCurr,bitIndex29)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_438,axiom,
    ! [VarCurr] :
      ( v7164(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_750,axiom,
    b11101(bitIndex4) ).

fof(bitBlastConstant_749,axiom,
    b11101(bitIndex3) ).

fof(bitBlastConstant_748,axiom,
    b11101(bitIndex2) ).

fof(bitBlastConstant_747,axiom,
    ~ b11101(bitIndex1) ).

fof(bitBlastConstant_746,axiom,
    b11101(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_73,axiom,
    ! [VarCurr] :
      ( ~ v7162(VarCurr)
     => ( v6549(VarCurr,bitIndex28)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_71,axiom,
    ! [VarCurr] :
      ( v7162(VarCurr)
     => ( v6549(VarCurr,bitIndex28)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_437,axiom,
    ! [VarCurr] :
      ( v7162(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_745,axiom,
    b11100(bitIndex4) ).

fof(bitBlastConstant_744,axiom,
    b11100(bitIndex3) ).

fof(bitBlastConstant_743,axiom,
    b11100(bitIndex2) ).

fof(bitBlastConstant_742,axiom,
    ~ b11100(bitIndex1) ).

fof(bitBlastConstant_741,axiom,
    ~ b11100(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_72,axiom,
    ! [VarCurr] :
      ( ~ v7160(VarCurr)
     => ( v6549(VarCurr,bitIndex27)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_70,axiom,
    ! [VarCurr] :
      ( v7160(VarCurr)
     => ( v6549(VarCurr,bitIndex27)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_436,axiom,
    ! [VarCurr] :
      ( v7160(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_740,axiom,
    b11011(bitIndex4) ).

fof(bitBlastConstant_739,axiom,
    b11011(bitIndex3) ).

fof(bitBlastConstant_738,axiom,
    ~ b11011(bitIndex2) ).

fof(bitBlastConstant_737,axiom,
    b11011(bitIndex1) ).

fof(bitBlastConstant_736,axiom,
    b11011(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_71,axiom,
    ! [VarCurr] :
      ( ~ v7158(VarCurr)
     => ( v6549(VarCurr,bitIndex26)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_69,axiom,
    ! [VarCurr] :
      ( v7158(VarCurr)
     => ( v6549(VarCurr,bitIndex26)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_435,axiom,
    ! [VarCurr] :
      ( v7158(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_735,axiom,
    b11010(bitIndex4) ).

fof(bitBlastConstant_734,axiom,
    b11010(bitIndex3) ).

fof(bitBlastConstant_733,axiom,
    ~ b11010(bitIndex2) ).

fof(bitBlastConstant_732,axiom,
    b11010(bitIndex1) ).

fof(bitBlastConstant_731,axiom,
    ~ b11010(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_70,axiom,
    ! [VarCurr] :
      ( ~ v7156(VarCurr)
     => ( v6549(VarCurr,bitIndex25)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_68,axiom,
    ! [VarCurr] :
      ( v7156(VarCurr)
     => ( v6549(VarCurr,bitIndex25)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_434,axiom,
    ! [VarCurr] :
      ( v7156(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_730,axiom,
    b11001(bitIndex4) ).

fof(bitBlastConstant_729,axiom,
    b11001(bitIndex3) ).

fof(bitBlastConstant_728,axiom,
    ~ b11001(bitIndex2) ).

fof(bitBlastConstant_727,axiom,
    ~ b11001(bitIndex1) ).

fof(bitBlastConstant_726,axiom,
    b11001(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_69,axiom,
    ! [VarCurr] :
      ( ~ v7154(VarCurr)
     => ( v6549(VarCurr,bitIndex24)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_67,axiom,
    ! [VarCurr] :
      ( v7154(VarCurr)
     => ( v6549(VarCurr,bitIndex24)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_433,axiom,
    ! [VarCurr] :
      ( v7154(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_725,axiom,
    b11000(bitIndex4) ).

fof(bitBlastConstant_724,axiom,
    b11000(bitIndex3) ).

fof(bitBlastConstant_723,axiom,
    ~ b11000(bitIndex2) ).

fof(bitBlastConstant_722,axiom,
    ~ b11000(bitIndex1) ).

fof(bitBlastConstant_721,axiom,
    ~ b11000(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_68,axiom,
    ! [VarCurr] :
      ( ~ v7152(VarCurr)
     => ( v6549(VarCurr,bitIndex23)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_66,axiom,
    ! [VarCurr] :
      ( v7152(VarCurr)
     => ( v6549(VarCurr,bitIndex23)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_432,axiom,
    ! [VarCurr] :
      ( v7152(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_720,axiom,
    b10111(bitIndex4) ).

fof(bitBlastConstant_719,axiom,
    ~ b10111(bitIndex3) ).

fof(bitBlastConstant_718,axiom,
    b10111(bitIndex2) ).

fof(bitBlastConstant_717,axiom,
    b10111(bitIndex1) ).

fof(bitBlastConstant_716,axiom,
    b10111(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_67,axiom,
    ! [VarCurr] :
      ( ~ v7150(VarCurr)
     => ( v6549(VarCurr,bitIndex22)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_65,axiom,
    ! [VarCurr] :
      ( v7150(VarCurr)
     => ( v6549(VarCurr,bitIndex22)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_431,axiom,
    ! [VarCurr] :
      ( v7150(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_715,axiom,
    b10110(bitIndex4) ).

fof(bitBlastConstant_714,axiom,
    ~ b10110(bitIndex3) ).

fof(bitBlastConstant_713,axiom,
    b10110(bitIndex2) ).

fof(bitBlastConstant_712,axiom,
    b10110(bitIndex1) ).

fof(bitBlastConstant_711,axiom,
    ~ b10110(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_66,axiom,
    ! [VarCurr] :
      ( ~ v7148(VarCurr)
     => ( v6549(VarCurr,bitIndex21)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_64,axiom,
    ! [VarCurr] :
      ( v7148(VarCurr)
     => ( v6549(VarCurr,bitIndex21)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_430,axiom,
    ! [VarCurr] :
      ( v7148(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_710,axiom,
    b10101(bitIndex4) ).

fof(bitBlastConstant_709,axiom,
    ~ b10101(bitIndex3) ).

fof(bitBlastConstant_708,axiom,
    b10101(bitIndex2) ).

fof(bitBlastConstant_707,axiom,
    ~ b10101(bitIndex1) ).

fof(bitBlastConstant_706,axiom,
    b10101(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_65,axiom,
    ! [VarCurr] :
      ( ~ v7146(VarCurr)
     => ( v6549(VarCurr,bitIndex20)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_63,axiom,
    ! [VarCurr] :
      ( v7146(VarCurr)
     => ( v6549(VarCurr,bitIndex20)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_429,axiom,
    ! [VarCurr] :
      ( v7146(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_705,axiom,
    b10100(bitIndex4) ).

fof(bitBlastConstant_704,axiom,
    ~ b10100(bitIndex3) ).

fof(bitBlastConstant_703,axiom,
    b10100(bitIndex2) ).

fof(bitBlastConstant_702,axiom,
    ~ b10100(bitIndex1) ).

fof(bitBlastConstant_701,axiom,
    ~ b10100(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_64,axiom,
    ! [VarCurr] :
      ( ~ v7144(VarCurr)
     => ( v6549(VarCurr,bitIndex19)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_62,axiom,
    ! [VarCurr] :
      ( v7144(VarCurr)
     => ( v6549(VarCurr,bitIndex19)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_428,axiom,
    ! [VarCurr] :
      ( v7144(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_700,axiom,
    b10011(bitIndex4) ).

fof(bitBlastConstant_699,axiom,
    ~ b10011(bitIndex3) ).

fof(bitBlastConstant_698,axiom,
    ~ b10011(bitIndex2) ).

fof(bitBlastConstant_697,axiom,
    b10011(bitIndex1) ).

fof(bitBlastConstant_696,axiom,
    b10011(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_63,axiom,
    ! [VarCurr] :
      ( ~ v7142(VarCurr)
     => ( v6549(VarCurr,bitIndex18)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_61,axiom,
    ! [VarCurr] :
      ( v7142(VarCurr)
     => ( v6549(VarCurr,bitIndex18)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_427,axiom,
    ! [VarCurr] :
      ( v7142(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_695,axiom,
    b10010(bitIndex4) ).

fof(bitBlastConstant_694,axiom,
    ~ b10010(bitIndex3) ).

fof(bitBlastConstant_693,axiom,
    ~ b10010(bitIndex2) ).

fof(bitBlastConstant_692,axiom,
    b10010(bitIndex1) ).

fof(bitBlastConstant_691,axiom,
    ~ b10010(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_62,axiom,
    ! [VarCurr] :
      ( ~ v7140(VarCurr)
     => ( v6549(VarCurr,bitIndex17)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_60,axiom,
    ! [VarCurr] :
      ( v7140(VarCurr)
     => ( v6549(VarCurr,bitIndex17)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_426,axiom,
    ! [VarCurr] :
      ( v7140(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_690,axiom,
    b10001(bitIndex4) ).

fof(bitBlastConstant_689,axiom,
    ~ b10001(bitIndex3) ).

fof(bitBlastConstant_688,axiom,
    ~ b10001(bitIndex2) ).

fof(bitBlastConstant_687,axiom,
    ~ b10001(bitIndex1) ).

fof(bitBlastConstant_686,axiom,
    b10001(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_61,axiom,
    ! [VarCurr] :
      ( ~ v7138(VarCurr)
     => ( v6549(VarCurr,bitIndex16)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_59,axiom,
    ! [VarCurr] :
      ( v7138(VarCurr)
     => ( v6549(VarCurr,bitIndex16)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_425,axiom,
    ! [VarCurr] :
      ( v7138(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $true )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_60,axiom,
    ! [VarCurr] :
      ( ~ v7136(VarCurr)
     => ( v6549(VarCurr,bitIndex15)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_58,axiom,
    ! [VarCurr] :
      ( v7136(VarCurr)
     => ( v6549(VarCurr,bitIndex15)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_424,axiom,
    ! [VarCurr] :
      ( v7136(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_685,axiom,
    ~ b01111(bitIndex4) ).

fof(bitBlastConstant_684,axiom,
    b01111(bitIndex3) ).

fof(bitBlastConstant_683,axiom,
    b01111(bitIndex2) ).

fof(bitBlastConstant_682,axiom,
    b01111(bitIndex1) ).

fof(bitBlastConstant_681,axiom,
    b01111(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_59,axiom,
    ! [VarCurr] :
      ( ~ v7134(VarCurr)
     => ( v6549(VarCurr,bitIndex14)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_57,axiom,
    ! [VarCurr] :
      ( v7134(VarCurr)
     => ( v6549(VarCurr,bitIndex14)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_423,axiom,
    ! [VarCurr] :
      ( v7134(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_680,axiom,
    ~ b01110(bitIndex4) ).

fof(bitBlastConstant_679,axiom,
    b01110(bitIndex3) ).

fof(bitBlastConstant_678,axiom,
    b01110(bitIndex2) ).

fof(bitBlastConstant_677,axiom,
    b01110(bitIndex1) ).

fof(bitBlastConstant_676,axiom,
    ~ b01110(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_58,axiom,
    ! [VarCurr] :
      ( ~ v7132(VarCurr)
     => ( v6549(VarCurr,bitIndex13)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_56,axiom,
    ! [VarCurr] :
      ( v7132(VarCurr)
     => ( v6549(VarCurr,bitIndex13)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_422,axiom,
    ! [VarCurr] :
      ( v7132(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_675,axiom,
    ~ b01101(bitIndex4) ).

fof(bitBlastConstant_674,axiom,
    b01101(bitIndex3) ).

fof(bitBlastConstant_673,axiom,
    b01101(bitIndex2) ).

fof(bitBlastConstant_672,axiom,
    ~ b01101(bitIndex1) ).

fof(bitBlastConstant_671,axiom,
    b01101(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_57,axiom,
    ! [VarCurr] :
      ( ~ v7130(VarCurr)
     => ( v6549(VarCurr,bitIndex12)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_55,axiom,
    ! [VarCurr] :
      ( v7130(VarCurr)
     => ( v6549(VarCurr,bitIndex12)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_421,axiom,
    ! [VarCurr] :
      ( v7130(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_670,axiom,
    ~ b01100(bitIndex4) ).

fof(bitBlastConstant_669,axiom,
    b01100(bitIndex3) ).

fof(bitBlastConstant_668,axiom,
    b01100(bitIndex2) ).

fof(bitBlastConstant_667,axiom,
    ~ b01100(bitIndex1) ).

fof(bitBlastConstant_666,axiom,
    ~ b01100(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_56,axiom,
    ! [VarCurr] :
      ( ~ v7128(VarCurr)
     => ( v6549(VarCurr,bitIndex11)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_54,axiom,
    ! [VarCurr] :
      ( v7128(VarCurr)
     => ( v6549(VarCurr,bitIndex11)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_420,axiom,
    ! [VarCurr] :
      ( v7128(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_665,axiom,
    ~ b01011(bitIndex4) ).

fof(bitBlastConstant_664,axiom,
    b01011(bitIndex3) ).

fof(bitBlastConstant_663,axiom,
    ~ b01011(bitIndex2) ).

fof(bitBlastConstant_662,axiom,
    b01011(bitIndex1) ).

fof(bitBlastConstant_661,axiom,
    b01011(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_55,axiom,
    ! [VarCurr] :
      ( ~ v7126(VarCurr)
     => ( v6549(VarCurr,bitIndex10)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_53,axiom,
    ! [VarCurr] :
      ( v7126(VarCurr)
     => ( v6549(VarCurr,bitIndex10)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_419,axiom,
    ! [VarCurr] :
      ( v7126(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_660,axiom,
    ~ b01010(bitIndex4) ).

fof(bitBlastConstant_659,axiom,
    b01010(bitIndex3) ).

fof(bitBlastConstant_658,axiom,
    ~ b01010(bitIndex2) ).

fof(bitBlastConstant_657,axiom,
    b01010(bitIndex1) ).

fof(bitBlastConstant_656,axiom,
    ~ b01010(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_54,axiom,
    ! [VarCurr] :
      ( ~ v7124(VarCurr)
     => ( v6549(VarCurr,bitIndex9)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_52,axiom,
    ! [VarCurr] :
      ( v7124(VarCurr)
     => ( v6549(VarCurr,bitIndex9)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_418,axiom,
    ! [VarCurr] :
      ( v7124(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_655,axiom,
    ~ b01001(bitIndex4) ).

fof(bitBlastConstant_654,axiom,
    b01001(bitIndex3) ).

fof(bitBlastConstant_653,axiom,
    ~ b01001(bitIndex2) ).

fof(bitBlastConstant_652,axiom,
    ~ b01001(bitIndex1) ).

fof(bitBlastConstant_651,axiom,
    b01001(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_53,axiom,
    ! [VarCurr] :
      ( ~ v7122(VarCurr)
     => ( v6549(VarCurr,bitIndex8)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_51,axiom,
    ! [VarCurr] :
      ( v7122(VarCurr)
     => ( v6549(VarCurr,bitIndex8)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_417,axiom,
    ! [VarCurr] :
      ( v7122(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $true )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_650,axiom,
    ~ b01000(bitIndex4) ).

fof(bitBlastConstant_649,axiom,
    b01000(bitIndex3) ).

fof(bitBlastConstant_648,axiom,
    ~ b01000(bitIndex2) ).

fof(bitBlastConstant_647,axiom,
    ~ b01000(bitIndex1) ).

fof(bitBlastConstant_646,axiom,
    ~ b01000(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_52,axiom,
    ! [VarCurr] :
      ( ~ v7120(VarCurr)
     => ( v6549(VarCurr,bitIndex7)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_50,axiom,
    ! [VarCurr] :
      ( v7120(VarCurr)
     => ( v6549(VarCurr,bitIndex7)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_416,axiom,
    ! [VarCurr] :
      ( v7120(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_645,axiom,
    ~ b00111(bitIndex4) ).

fof(bitBlastConstant_644,axiom,
    ~ b00111(bitIndex3) ).

fof(bitBlastConstant_643,axiom,
    b00111(bitIndex2) ).

fof(bitBlastConstant_642,axiom,
    b00111(bitIndex1) ).

fof(bitBlastConstant_641,axiom,
    b00111(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_51,axiom,
    ! [VarCurr] :
      ( ~ v7118(VarCurr)
     => ( v6549(VarCurr,bitIndex6)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_49,axiom,
    ! [VarCurr] :
      ( v7118(VarCurr)
     => ( v6549(VarCurr,bitIndex6)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_415,axiom,
    ! [VarCurr] :
      ( v7118(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_640,axiom,
    ~ b00110(bitIndex4) ).

fof(bitBlastConstant_639,axiom,
    ~ b00110(bitIndex3) ).

fof(bitBlastConstant_638,axiom,
    b00110(bitIndex2) ).

fof(bitBlastConstant_637,axiom,
    b00110(bitIndex1) ).

fof(bitBlastConstant_636,axiom,
    ~ b00110(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_50,axiom,
    ! [VarCurr] :
      ( ~ v7116(VarCurr)
     => ( v6549(VarCurr,bitIndex5)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_48,axiom,
    ! [VarCurr] :
      ( v7116(VarCurr)
     => ( v6549(VarCurr,bitIndex5)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_414,axiom,
    ! [VarCurr] :
      ( v7116(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_635,axiom,
    ~ b00101(bitIndex4) ).

fof(bitBlastConstant_634,axiom,
    ~ b00101(bitIndex3) ).

fof(bitBlastConstant_633,axiom,
    b00101(bitIndex2) ).

fof(bitBlastConstant_632,axiom,
    ~ b00101(bitIndex1) ).

fof(bitBlastConstant_631,axiom,
    b00101(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_49,axiom,
    ! [VarCurr] :
      ( ~ v7114(VarCurr)
     => ( v6549(VarCurr,bitIndex4)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_47,axiom,
    ! [VarCurr] :
      ( v7114(VarCurr)
     => ( v6549(VarCurr,bitIndex4)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_413,axiom,
    ! [VarCurr] :
      ( v7114(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $true )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_630,axiom,
    ~ b00100(bitIndex4) ).

fof(bitBlastConstant_629,axiom,
    ~ b00100(bitIndex3) ).

fof(bitBlastConstant_628,axiom,
    b00100(bitIndex2) ).

fof(bitBlastConstant_627,axiom,
    ~ b00100(bitIndex1) ).

fof(bitBlastConstant_626,axiom,
    ~ b00100(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_48,axiom,
    ! [VarCurr] :
      ( ~ v7112(VarCurr)
     => ( v6549(VarCurr,bitIndex3)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_46,axiom,
    ! [VarCurr] :
      ( v7112(VarCurr)
     => ( v6549(VarCurr,bitIndex3)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_412,axiom,
    ! [VarCurr] :
      ( v7112(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_625,axiom,
    ~ b00011(bitIndex4) ).

fof(bitBlastConstant_624,axiom,
    ~ b00011(bitIndex3) ).

fof(bitBlastConstant_623,axiom,
    ~ b00011(bitIndex2) ).

fof(bitBlastConstant_622,axiom,
    b00011(bitIndex1) ).

fof(bitBlastConstant_621,axiom,
    b00011(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_47,axiom,
    ! [VarCurr] :
      ( ~ v7110(VarCurr)
     => ( v6549(VarCurr,bitIndex2)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_45,axiom,
    ! [VarCurr] :
      ( v7110(VarCurr)
     => ( v6549(VarCurr,bitIndex2)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_411,axiom,
    ! [VarCurr] :
      ( v7110(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $true )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_620,axiom,
    ~ b00010(bitIndex4) ).

fof(bitBlastConstant_619,axiom,
    ~ b00010(bitIndex3) ).

fof(bitBlastConstant_618,axiom,
    ~ b00010(bitIndex2) ).

fof(bitBlastConstant_617,axiom,
    b00010(bitIndex1) ).

fof(bitBlastConstant_616,axiom,
    ~ b00010(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_46,axiom,
    ! [VarCurr] :
      ( ~ v7108(VarCurr)
     => ( v6549(VarCurr,bitIndex1)
      <=> $true ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_44,axiom,
    ! [VarCurr] :
      ( v7108(VarCurr)
     => ( v6549(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_410,axiom,
    ! [VarCurr] :
      ( v7108(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_615,axiom,
    ~ b00001(bitIndex4) ).

fof(bitBlastConstant_614,axiom,
    ~ b00001(bitIndex3) ).

fof(bitBlastConstant_613,axiom,
    ~ b00001(bitIndex2) ).

fof(bitBlastConstant_612,axiom,
    ~ b00001(bitIndex1) ).

fof(bitBlastConstant_611,axiom,
    b00001(bitIndex0) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_179,axiom,
    ! [VarCurr] :
      ( ~ v7106(VarCurr)
     => ( v6549(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_181,axiom,
    ! [VarCurr] :
      ( v7106(VarCurr)
     => ( v6549(VarCurr,bitIndex0)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_409,axiom,
    ! [VarCurr] :
      ( v7106(VarCurr)
    <=> ( ( v6551(VarCurr,bitIndex4)
        <=> $false )
        & ( v6551(VarCurr,bitIndex3)
        <=> $false )
        & ( v6551(VarCurr,bitIndex2)
        <=> $false )
        & ( v6551(VarCurr,bitIndex1)
        <=> $false )
        & ( v6551(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1762,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6551(VarCurr,B)
      <=> v6553(VarCurr,B) ) ) ).

fof(addAssignment_1761,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6553(VarCurr,B)
      <=> v6555(VarCurr,B) ) ) ).

fof(addAssignment_1760,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6555(VarCurr,B)
      <=> v6557(VarCurr,B) ) ) ).

fof(addAssignment_1759,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6557(VarCurr,B)
      <=> v6559(VarCurr,B) ) ) ).

fof(addAssignment_1758,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6559(VarCurr,B)
      <=> v7082(VarCurr,B) ) ) ).

fof(memoryReadIntoBuffer_19,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b0000_address_term = A
             => ( range_53_0(B)
               => ( v6926(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_18,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b0001_address_term = A
             => ( range_53_0(B)
               => ( v6935(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_17,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b0010_address_term = A
             => ( range_53_0(B)
               => ( v6944(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_16,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b0011_address_term = A
             => ( range_53_0(B)
               => ( v6953(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_15,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b0100_address_term = A
             => ( range_53_0(B)
               => ( v6962(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_14,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b0101_address_term = A
             => ( range_53_0(B)
               => ( v6971(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_13,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b0110_address_term = A
             => ( range_53_0(B)
               => ( v6980(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_12,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b0111_address_term = A
             => ( range_53_0(B)
               => ( v6989(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_11,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b1000_address_term = A
             => ( range_53_0(B)
               => ( v6998(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_10,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b1001_address_term = A
             => ( range_53_0(B)
               => ( v7007(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_9,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b1010_address_term = A
             => ( range_53_0(B)
               => ( v7016(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_8,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b1011_address_term = A
             => ( range_53_0(B)
               => ( v7025(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_7,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b1100_address_term = A
             => ( range_53_0(B)
               => ( v7034(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_6,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b1101_address_term = A
             => ( range_53_0(B)
               => ( v7043(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_5,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b1110_address_term = A
             => ( range_53_0(B)
               => ( v7052(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_4,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( address(A)
         => ! [B] :
              ( b1111_address_term = A
             => ( range_53_0(B)
               => ( v7061(VarNext,B)
                <=> v6561_array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryReadIntoBuffer_3,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v6904_range_3_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( address(A)
             => ! [B] :
                  ( A = AssociatedAddressVar
                 => ( range_53_0(B)
                   => ( v7082(VarNext,B)
                    <=> v6561_array(VarNext,A,B) ) ) ) ) ) ) ).

fof(memoryConstantWriteDisabled_3,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( $true
              & v7074(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_array(VarNext,A,B)
              <=> v6561_17__array(VarNext,A,B) ) ) ) ) ).

fof(memoryConstantWriteEnabledInsideRange_3,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( $true
            & v7074(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_array(VarNext,A,B)
              <=> b000000000000000000000000000000000000000000000000000000(B) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1290,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7074(VarNext)
      <=> ( v7075(VarNext)
          & v7080(VarNext) ) ) ) ).

fof(addAssignment_1757,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7080(VarNext)
      <=> v6923(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1289,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7075(VarNext)
      <=> ( v7077(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_607,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7077(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_19,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v6904_range_3_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ~ ( A = AssociatedAddressVar
                  & v7064(VarNext) )
             => ! [B] :
                  ( range_53_0(B)
                 => ( v6561_17__array(VarNext,A,B)
                  <=> v6561_16__array(VarNext,A,B) ) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_19,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v6904_range_3_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ( A = AssociatedAddressVar
                & v7064(VarNext) )
             => ! [B] :
                  ( range_53_0(B)
                 => ( v6561_17__array(VarNext,A,B)
                  <=> v6568(VarNext,B) ) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1288,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7064(VarNext)
      <=> ( v7065(VarNext)
          & v7071(VarNext) ) ) ) ).

fof(addAssignment_1756,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7071(VarNext)
      <=> v7069(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1287,axiom,
    ! [VarCurr] :
      ( v7069(VarCurr)
    <=> ( v6922(VarCurr)
        & v6883(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1286,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7065(VarNext)
      <=> ( v7067(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_606,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7067(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_18,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b1111_address_term = A
              & v7055(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_16__array(VarNext,A,B)
              <=> v6561_15__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_18,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b1111_address_term = A
            & v7055(VarNext) )
         => ( ( v6561_16__array(VarNext,A,bitIndex53)
            <=> v7061(VarNext,bitIndex863) )
            & ( v6561_16__array(VarNext,A,bitIndex52)
            <=> v7061(VarNext,bitIndex862) )
            & ( v6561_16__array(VarNext,A,bitIndex51)
            <=> v7061(VarNext,bitIndex861) )
            & ( v6561_16__array(VarNext,A,bitIndex50)
            <=> v7061(VarNext,bitIndex860) )
            & ( v6561_16__array(VarNext,A,bitIndex49)
            <=> v7061(VarNext,bitIndex859) )
            & ( v6561_16__array(VarNext,A,bitIndex48)
            <=> v7061(VarNext,bitIndex858) )
            & ( v6561_16__array(VarNext,A,bitIndex47)
            <=> v7061(VarNext,bitIndex857) )
            & ( v6561_16__array(VarNext,A,bitIndex46)
            <=> v7061(VarNext,bitIndex856) )
            & ( v6561_16__array(VarNext,A,bitIndex45)
            <=> v7061(VarNext,bitIndex855) )
            & ( v6561_16__array(VarNext,A,bitIndex44)
            <=> v7061(VarNext,bitIndex854) )
            & ( v6561_16__array(VarNext,A,bitIndex43)
            <=> v7061(VarNext,bitIndex853) )
            & ( v6561_16__array(VarNext,A,bitIndex42)
            <=> v7061(VarNext,bitIndex852) )
            & ( v6561_16__array(VarNext,A,bitIndex41)
            <=> v7061(VarNext,bitIndex851) )
            & ( v6561_16__array(VarNext,A,bitIndex40)
            <=> v7061(VarNext,bitIndex850) )
            & ( v6561_16__array(VarNext,A,bitIndex39)
            <=> v7061(VarNext,bitIndex849) )
            & ( v6561_16__array(VarNext,A,bitIndex38)
            <=> v7061(VarNext,bitIndex848) )
            & ( v6561_16__array(VarNext,A,bitIndex37)
            <=> v7061(VarNext,bitIndex847) )
            & ( v6561_16__array(VarNext,A,bitIndex36)
            <=> v7061(VarNext,bitIndex846) )
            & ( v6561_16__array(VarNext,A,bitIndex35)
            <=> v7061(VarNext,bitIndex845) )
            & ( v6561_16__array(VarNext,A,bitIndex34)
            <=> v7061(VarNext,bitIndex844) )
            & ( v6561_16__array(VarNext,A,bitIndex33)
            <=> v7061(VarNext,bitIndex843) )
            & ( v6561_16__array(VarNext,A,bitIndex32)
            <=> v7061(VarNext,bitIndex842) )
            & ( v6561_16__array(VarNext,A,bitIndex31)
            <=> v7061(VarNext,bitIndex841) )
            & ( v6561_16__array(VarNext,A,bitIndex30)
            <=> v7061(VarNext,bitIndex840) )
            & ( v6561_16__array(VarNext,A,bitIndex29)
            <=> v7061(VarNext,bitIndex839) )
            & ( v6561_16__array(VarNext,A,bitIndex28)
            <=> v7061(VarNext,bitIndex838) )
            & ( v6561_16__array(VarNext,A,bitIndex27)
            <=> v7061(VarNext,bitIndex837) )
            & ( v6561_16__array(VarNext,A,bitIndex26)
            <=> v7061(VarNext,bitIndex836) )
            & ( v6561_16__array(VarNext,A,bitIndex25)
            <=> v7061(VarNext,bitIndex835) )
            & ( v6561_16__array(VarNext,A,bitIndex24)
            <=> v7061(VarNext,bitIndex834) )
            & ( v6561_16__array(VarNext,A,bitIndex23)
            <=> v7061(VarNext,bitIndex833) )
            & ( v6561_16__array(VarNext,A,bitIndex22)
            <=> v7061(VarNext,bitIndex832) )
            & ( v6561_16__array(VarNext,A,bitIndex21)
            <=> v7061(VarNext,bitIndex831) )
            & ( v6561_16__array(VarNext,A,bitIndex20)
            <=> v7061(VarNext,bitIndex830) )
            & ( v6561_16__array(VarNext,A,bitIndex19)
            <=> v7061(VarNext,bitIndex829) )
            & ( v6561_16__array(VarNext,A,bitIndex18)
            <=> v7061(VarNext,bitIndex828) )
            & ( v6561_16__array(VarNext,A,bitIndex17)
            <=> v7061(VarNext,bitIndex827) )
            & ( v6561_16__array(VarNext,A,bitIndex16)
            <=> v7061(VarNext,bitIndex826) )
            & ( v6561_16__array(VarNext,A,bitIndex15)
            <=> v7061(VarNext,bitIndex825) )
            & ( v6561_16__array(VarNext,A,bitIndex14)
            <=> v7061(VarNext,bitIndex824) )
            & ( v6561_16__array(VarNext,A,bitIndex13)
            <=> v7061(VarNext,bitIndex823) )
            & ( v6561_16__array(VarNext,A,bitIndex12)
            <=> v7061(VarNext,bitIndex822) )
            & ( v6561_16__array(VarNext,A,bitIndex11)
            <=> v7061(VarNext,bitIndex821) )
            & ( v6561_16__array(VarNext,A,bitIndex10)
            <=> v7061(VarNext,bitIndex820) )
            & ( v6561_16__array(VarNext,A,bitIndex9)
            <=> v7061(VarNext,bitIndex819) )
            & ( v6561_16__array(VarNext,A,bitIndex8)
            <=> v7061(VarNext,bitIndex818) )
            & ( v6561_16__array(VarNext,A,bitIndex7)
            <=> v7061(VarNext,bitIndex817) )
            & ( v6561_16__array(VarNext,A,bitIndex6)
            <=> v7061(VarNext,bitIndex816) )
            & ( v6561_16__array(VarNext,A,bitIndex5)
            <=> v7061(VarNext,bitIndex815) )
            & ( v6561_16__array(VarNext,A,bitIndex4)
            <=> v7061(VarNext,bitIndex814) )
            & ( v6561_16__array(VarNext,A,bitIndex3)
            <=> v7061(VarNext,bitIndex813) )
            & ( v6561_16__array(VarNext,A,bitIndex2)
            <=> v7061(VarNext,bitIndex812) )
            & ( v6561_16__array(VarNext,A,bitIndex1)
            <=> v7061(VarNext,bitIndex811) )
            & ( v6561_16__array(VarNext,A,bitIndex0)
            <=> v7061(VarNext,bitIndex810) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1285,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7055(VarNext)
      <=> ( v7056(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1284,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7056(VarNext)
      <=> ( v7058(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_605,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7058(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_17,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b1110_address_term = A
              & v7046(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_15__array(VarNext,A,B)
              <=> v6561_14__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_17,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b1110_address_term = A
            & v7046(VarNext) )
         => ( ( v6561_15__array(VarNext,A,bitIndex53)
            <=> v7052(VarNext,bitIndex809) )
            & ( v6561_15__array(VarNext,A,bitIndex52)
            <=> v7052(VarNext,bitIndex808) )
            & ( v6561_15__array(VarNext,A,bitIndex51)
            <=> v7052(VarNext,bitIndex807) )
            & ( v6561_15__array(VarNext,A,bitIndex50)
            <=> v7052(VarNext,bitIndex806) )
            & ( v6561_15__array(VarNext,A,bitIndex49)
            <=> v7052(VarNext,bitIndex805) )
            & ( v6561_15__array(VarNext,A,bitIndex48)
            <=> v7052(VarNext,bitIndex804) )
            & ( v6561_15__array(VarNext,A,bitIndex47)
            <=> v7052(VarNext,bitIndex803) )
            & ( v6561_15__array(VarNext,A,bitIndex46)
            <=> v7052(VarNext,bitIndex802) )
            & ( v6561_15__array(VarNext,A,bitIndex45)
            <=> v7052(VarNext,bitIndex801) )
            & ( v6561_15__array(VarNext,A,bitIndex44)
            <=> v7052(VarNext,bitIndex800) )
            & ( v6561_15__array(VarNext,A,bitIndex43)
            <=> v7052(VarNext,bitIndex799) )
            & ( v6561_15__array(VarNext,A,bitIndex42)
            <=> v7052(VarNext,bitIndex798) )
            & ( v6561_15__array(VarNext,A,bitIndex41)
            <=> v7052(VarNext,bitIndex797) )
            & ( v6561_15__array(VarNext,A,bitIndex40)
            <=> v7052(VarNext,bitIndex796) )
            & ( v6561_15__array(VarNext,A,bitIndex39)
            <=> v7052(VarNext,bitIndex795) )
            & ( v6561_15__array(VarNext,A,bitIndex38)
            <=> v7052(VarNext,bitIndex794) )
            & ( v6561_15__array(VarNext,A,bitIndex37)
            <=> v7052(VarNext,bitIndex793) )
            & ( v6561_15__array(VarNext,A,bitIndex36)
            <=> v7052(VarNext,bitIndex792) )
            & ( v6561_15__array(VarNext,A,bitIndex35)
            <=> v7052(VarNext,bitIndex791) )
            & ( v6561_15__array(VarNext,A,bitIndex34)
            <=> v7052(VarNext,bitIndex790) )
            & ( v6561_15__array(VarNext,A,bitIndex33)
            <=> v7052(VarNext,bitIndex789) )
            & ( v6561_15__array(VarNext,A,bitIndex32)
            <=> v7052(VarNext,bitIndex788) )
            & ( v6561_15__array(VarNext,A,bitIndex31)
            <=> v7052(VarNext,bitIndex787) )
            & ( v6561_15__array(VarNext,A,bitIndex30)
            <=> v7052(VarNext,bitIndex786) )
            & ( v6561_15__array(VarNext,A,bitIndex29)
            <=> v7052(VarNext,bitIndex785) )
            & ( v6561_15__array(VarNext,A,bitIndex28)
            <=> v7052(VarNext,bitIndex784) )
            & ( v6561_15__array(VarNext,A,bitIndex27)
            <=> v7052(VarNext,bitIndex783) )
            & ( v6561_15__array(VarNext,A,bitIndex26)
            <=> v7052(VarNext,bitIndex782) )
            & ( v6561_15__array(VarNext,A,bitIndex25)
            <=> v7052(VarNext,bitIndex781) )
            & ( v6561_15__array(VarNext,A,bitIndex24)
            <=> v7052(VarNext,bitIndex780) )
            & ( v6561_15__array(VarNext,A,bitIndex23)
            <=> v7052(VarNext,bitIndex779) )
            & ( v6561_15__array(VarNext,A,bitIndex22)
            <=> v7052(VarNext,bitIndex778) )
            & ( v6561_15__array(VarNext,A,bitIndex21)
            <=> v7052(VarNext,bitIndex777) )
            & ( v6561_15__array(VarNext,A,bitIndex20)
            <=> v7052(VarNext,bitIndex776) )
            & ( v6561_15__array(VarNext,A,bitIndex19)
            <=> v7052(VarNext,bitIndex775) )
            & ( v6561_15__array(VarNext,A,bitIndex18)
            <=> v7052(VarNext,bitIndex774) )
            & ( v6561_15__array(VarNext,A,bitIndex17)
            <=> v7052(VarNext,bitIndex773) )
            & ( v6561_15__array(VarNext,A,bitIndex16)
            <=> v7052(VarNext,bitIndex772) )
            & ( v6561_15__array(VarNext,A,bitIndex15)
            <=> v7052(VarNext,bitIndex771) )
            & ( v6561_15__array(VarNext,A,bitIndex14)
            <=> v7052(VarNext,bitIndex770) )
            & ( v6561_15__array(VarNext,A,bitIndex13)
            <=> v7052(VarNext,bitIndex769) )
            & ( v6561_15__array(VarNext,A,bitIndex12)
            <=> v7052(VarNext,bitIndex768) )
            & ( v6561_15__array(VarNext,A,bitIndex11)
            <=> v7052(VarNext,bitIndex767) )
            & ( v6561_15__array(VarNext,A,bitIndex10)
            <=> v7052(VarNext,bitIndex766) )
            & ( v6561_15__array(VarNext,A,bitIndex9)
            <=> v7052(VarNext,bitIndex765) )
            & ( v6561_15__array(VarNext,A,bitIndex8)
            <=> v7052(VarNext,bitIndex764) )
            & ( v6561_15__array(VarNext,A,bitIndex7)
            <=> v7052(VarNext,bitIndex763) )
            & ( v6561_15__array(VarNext,A,bitIndex6)
            <=> v7052(VarNext,bitIndex762) )
            & ( v6561_15__array(VarNext,A,bitIndex5)
            <=> v7052(VarNext,bitIndex761) )
            & ( v6561_15__array(VarNext,A,bitIndex4)
            <=> v7052(VarNext,bitIndex760) )
            & ( v6561_15__array(VarNext,A,bitIndex3)
            <=> v7052(VarNext,bitIndex759) )
            & ( v6561_15__array(VarNext,A,bitIndex2)
            <=> v7052(VarNext,bitIndex758) )
            & ( v6561_15__array(VarNext,A,bitIndex1)
            <=> v7052(VarNext,bitIndex757) )
            & ( v6561_15__array(VarNext,A,bitIndex0)
            <=> v7052(VarNext,bitIndex756) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1283,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7046(VarNext)
      <=> ( v7047(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1282,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7047(VarNext)
      <=> ( v7049(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_604,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7049(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_16,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b1101_address_term = A
              & v7037(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_14__array(VarNext,A,B)
              <=> v6561_13__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_16,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b1101_address_term = A
            & v7037(VarNext) )
         => ( ( v6561_14__array(VarNext,A,bitIndex53)
            <=> v7043(VarNext,bitIndex755) )
            & ( v6561_14__array(VarNext,A,bitIndex52)
            <=> v7043(VarNext,bitIndex754) )
            & ( v6561_14__array(VarNext,A,bitIndex51)
            <=> v7043(VarNext,bitIndex753) )
            & ( v6561_14__array(VarNext,A,bitIndex50)
            <=> v7043(VarNext,bitIndex752) )
            & ( v6561_14__array(VarNext,A,bitIndex49)
            <=> v7043(VarNext,bitIndex751) )
            & ( v6561_14__array(VarNext,A,bitIndex48)
            <=> v7043(VarNext,bitIndex750) )
            & ( v6561_14__array(VarNext,A,bitIndex47)
            <=> v7043(VarNext,bitIndex749) )
            & ( v6561_14__array(VarNext,A,bitIndex46)
            <=> v7043(VarNext,bitIndex748) )
            & ( v6561_14__array(VarNext,A,bitIndex45)
            <=> v7043(VarNext,bitIndex747) )
            & ( v6561_14__array(VarNext,A,bitIndex44)
            <=> v7043(VarNext,bitIndex746) )
            & ( v6561_14__array(VarNext,A,bitIndex43)
            <=> v7043(VarNext,bitIndex745) )
            & ( v6561_14__array(VarNext,A,bitIndex42)
            <=> v7043(VarNext,bitIndex744) )
            & ( v6561_14__array(VarNext,A,bitIndex41)
            <=> v7043(VarNext,bitIndex743) )
            & ( v6561_14__array(VarNext,A,bitIndex40)
            <=> v7043(VarNext,bitIndex742) )
            & ( v6561_14__array(VarNext,A,bitIndex39)
            <=> v7043(VarNext,bitIndex741) )
            & ( v6561_14__array(VarNext,A,bitIndex38)
            <=> v7043(VarNext,bitIndex740) )
            & ( v6561_14__array(VarNext,A,bitIndex37)
            <=> v7043(VarNext,bitIndex739) )
            & ( v6561_14__array(VarNext,A,bitIndex36)
            <=> v7043(VarNext,bitIndex738) )
            & ( v6561_14__array(VarNext,A,bitIndex35)
            <=> v7043(VarNext,bitIndex737) )
            & ( v6561_14__array(VarNext,A,bitIndex34)
            <=> v7043(VarNext,bitIndex736) )
            & ( v6561_14__array(VarNext,A,bitIndex33)
            <=> v7043(VarNext,bitIndex735) )
            & ( v6561_14__array(VarNext,A,bitIndex32)
            <=> v7043(VarNext,bitIndex734) )
            & ( v6561_14__array(VarNext,A,bitIndex31)
            <=> v7043(VarNext,bitIndex733) )
            & ( v6561_14__array(VarNext,A,bitIndex30)
            <=> v7043(VarNext,bitIndex732) )
            & ( v6561_14__array(VarNext,A,bitIndex29)
            <=> v7043(VarNext,bitIndex731) )
            & ( v6561_14__array(VarNext,A,bitIndex28)
            <=> v7043(VarNext,bitIndex730) )
            & ( v6561_14__array(VarNext,A,bitIndex27)
            <=> v7043(VarNext,bitIndex729) )
            & ( v6561_14__array(VarNext,A,bitIndex26)
            <=> v7043(VarNext,bitIndex728) )
            & ( v6561_14__array(VarNext,A,bitIndex25)
            <=> v7043(VarNext,bitIndex727) )
            & ( v6561_14__array(VarNext,A,bitIndex24)
            <=> v7043(VarNext,bitIndex726) )
            & ( v6561_14__array(VarNext,A,bitIndex23)
            <=> v7043(VarNext,bitIndex725) )
            & ( v6561_14__array(VarNext,A,bitIndex22)
            <=> v7043(VarNext,bitIndex724) )
            & ( v6561_14__array(VarNext,A,bitIndex21)
            <=> v7043(VarNext,bitIndex723) )
            & ( v6561_14__array(VarNext,A,bitIndex20)
            <=> v7043(VarNext,bitIndex722) )
            & ( v6561_14__array(VarNext,A,bitIndex19)
            <=> v7043(VarNext,bitIndex721) )
            & ( v6561_14__array(VarNext,A,bitIndex18)
            <=> v7043(VarNext,bitIndex720) )
            & ( v6561_14__array(VarNext,A,bitIndex17)
            <=> v7043(VarNext,bitIndex719) )
            & ( v6561_14__array(VarNext,A,bitIndex16)
            <=> v7043(VarNext,bitIndex718) )
            & ( v6561_14__array(VarNext,A,bitIndex15)
            <=> v7043(VarNext,bitIndex717) )
            & ( v6561_14__array(VarNext,A,bitIndex14)
            <=> v7043(VarNext,bitIndex716) )
            & ( v6561_14__array(VarNext,A,bitIndex13)
            <=> v7043(VarNext,bitIndex715) )
            & ( v6561_14__array(VarNext,A,bitIndex12)
            <=> v7043(VarNext,bitIndex714) )
            & ( v6561_14__array(VarNext,A,bitIndex11)
            <=> v7043(VarNext,bitIndex713) )
            & ( v6561_14__array(VarNext,A,bitIndex10)
            <=> v7043(VarNext,bitIndex712) )
            & ( v6561_14__array(VarNext,A,bitIndex9)
            <=> v7043(VarNext,bitIndex711) )
            & ( v6561_14__array(VarNext,A,bitIndex8)
            <=> v7043(VarNext,bitIndex710) )
            & ( v6561_14__array(VarNext,A,bitIndex7)
            <=> v7043(VarNext,bitIndex709) )
            & ( v6561_14__array(VarNext,A,bitIndex6)
            <=> v7043(VarNext,bitIndex708) )
            & ( v6561_14__array(VarNext,A,bitIndex5)
            <=> v7043(VarNext,bitIndex707) )
            & ( v6561_14__array(VarNext,A,bitIndex4)
            <=> v7043(VarNext,bitIndex706) )
            & ( v6561_14__array(VarNext,A,bitIndex3)
            <=> v7043(VarNext,bitIndex705) )
            & ( v6561_14__array(VarNext,A,bitIndex2)
            <=> v7043(VarNext,bitIndex704) )
            & ( v6561_14__array(VarNext,A,bitIndex1)
            <=> v7043(VarNext,bitIndex703) )
            & ( v6561_14__array(VarNext,A,bitIndex0)
            <=> v7043(VarNext,bitIndex702) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1281,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7037(VarNext)
      <=> ( v7038(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1280,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7038(VarNext)
      <=> ( v7040(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_603,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7040(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_15,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b1100_address_term = A
              & v7028(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_13__array(VarNext,A,B)
              <=> v6561_12__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_15,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b1100_address_term = A
            & v7028(VarNext) )
         => ( ( v6561_13__array(VarNext,A,bitIndex53)
            <=> v7034(VarNext,bitIndex701) )
            & ( v6561_13__array(VarNext,A,bitIndex52)
            <=> v7034(VarNext,bitIndex700) )
            & ( v6561_13__array(VarNext,A,bitIndex51)
            <=> v7034(VarNext,bitIndex699) )
            & ( v6561_13__array(VarNext,A,bitIndex50)
            <=> v7034(VarNext,bitIndex698) )
            & ( v6561_13__array(VarNext,A,bitIndex49)
            <=> v7034(VarNext,bitIndex697) )
            & ( v6561_13__array(VarNext,A,bitIndex48)
            <=> v7034(VarNext,bitIndex696) )
            & ( v6561_13__array(VarNext,A,bitIndex47)
            <=> v7034(VarNext,bitIndex695) )
            & ( v6561_13__array(VarNext,A,bitIndex46)
            <=> v7034(VarNext,bitIndex694) )
            & ( v6561_13__array(VarNext,A,bitIndex45)
            <=> v7034(VarNext,bitIndex693) )
            & ( v6561_13__array(VarNext,A,bitIndex44)
            <=> v7034(VarNext,bitIndex692) )
            & ( v6561_13__array(VarNext,A,bitIndex43)
            <=> v7034(VarNext,bitIndex691) )
            & ( v6561_13__array(VarNext,A,bitIndex42)
            <=> v7034(VarNext,bitIndex690) )
            & ( v6561_13__array(VarNext,A,bitIndex41)
            <=> v7034(VarNext,bitIndex689) )
            & ( v6561_13__array(VarNext,A,bitIndex40)
            <=> v7034(VarNext,bitIndex688) )
            & ( v6561_13__array(VarNext,A,bitIndex39)
            <=> v7034(VarNext,bitIndex687) )
            & ( v6561_13__array(VarNext,A,bitIndex38)
            <=> v7034(VarNext,bitIndex686) )
            & ( v6561_13__array(VarNext,A,bitIndex37)
            <=> v7034(VarNext,bitIndex685) )
            & ( v6561_13__array(VarNext,A,bitIndex36)
            <=> v7034(VarNext,bitIndex684) )
            & ( v6561_13__array(VarNext,A,bitIndex35)
            <=> v7034(VarNext,bitIndex683) )
            & ( v6561_13__array(VarNext,A,bitIndex34)
            <=> v7034(VarNext,bitIndex682) )
            & ( v6561_13__array(VarNext,A,bitIndex33)
            <=> v7034(VarNext,bitIndex681) )
            & ( v6561_13__array(VarNext,A,bitIndex32)
            <=> v7034(VarNext,bitIndex680) )
            & ( v6561_13__array(VarNext,A,bitIndex31)
            <=> v7034(VarNext,bitIndex679) )
            & ( v6561_13__array(VarNext,A,bitIndex30)
            <=> v7034(VarNext,bitIndex678) )
            & ( v6561_13__array(VarNext,A,bitIndex29)
            <=> v7034(VarNext,bitIndex677) )
            & ( v6561_13__array(VarNext,A,bitIndex28)
            <=> v7034(VarNext,bitIndex676) )
            & ( v6561_13__array(VarNext,A,bitIndex27)
            <=> v7034(VarNext,bitIndex675) )
            & ( v6561_13__array(VarNext,A,bitIndex26)
            <=> v7034(VarNext,bitIndex674) )
            & ( v6561_13__array(VarNext,A,bitIndex25)
            <=> v7034(VarNext,bitIndex673) )
            & ( v6561_13__array(VarNext,A,bitIndex24)
            <=> v7034(VarNext,bitIndex672) )
            & ( v6561_13__array(VarNext,A,bitIndex23)
            <=> v7034(VarNext,bitIndex671) )
            & ( v6561_13__array(VarNext,A,bitIndex22)
            <=> v7034(VarNext,bitIndex670) )
            & ( v6561_13__array(VarNext,A,bitIndex21)
            <=> v7034(VarNext,bitIndex669) )
            & ( v6561_13__array(VarNext,A,bitIndex20)
            <=> v7034(VarNext,bitIndex668) )
            & ( v6561_13__array(VarNext,A,bitIndex19)
            <=> v7034(VarNext,bitIndex667) )
            & ( v6561_13__array(VarNext,A,bitIndex18)
            <=> v7034(VarNext,bitIndex666) )
            & ( v6561_13__array(VarNext,A,bitIndex17)
            <=> v7034(VarNext,bitIndex665) )
            & ( v6561_13__array(VarNext,A,bitIndex16)
            <=> v7034(VarNext,bitIndex664) )
            & ( v6561_13__array(VarNext,A,bitIndex15)
            <=> v7034(VarNext,bitIndex663) )
            & ( v6561_13__array(VarNext,A,bitIndex14)
            <=> v7034(VarNext,bitIndex662) )
            & ( v6561_13__array(VarNext,A,bitIndex13)
            <=> v7034(VarNext,bitIndex661) )
            & ( v6561_13__array(VarNext,A,bitIndex12)
            <=> v7034(VarNext,bitIndex660) )
            & ( v6561_13__array(VarNext,A,bitIndex11)
            <=> v7034(VarNext,bitIndex659) )
            & ( v6561_13__array(VarNext,A,bitIndex10)
            <=> v7034(VarNext,bitIndex658) )
            & ( v6561_13__array(VarNext,A,bitIndex9)
            <=> v7034(VarNext,bitIndex657) )
            & ( v6561_13__array(VarNext,A,bitIndex8)
            <=> v7034(VarNext,bitIndex656) )
            & ( v6561_13__array(VarNext,A,bitIndex7)
            <=> v7034(VarNext,bitIndex655) )
            & ( v6561_13__array(VarNext,A,bitIndex6)
            <=> v7034(VarNext,bitIndex654) )
            & ( v6561_13__array(VarNext,A,bitIndex5)
            <=> v7034(VarNext,bitIndex653) )
            & ( v6561_13__array(VarNext,A,bitIndex4)
            <=> v7034(VarNext,bitIndex652) )
            & ( v6561_13__array(VarNext,A,bitIndex3)
            <=> v7034(VarNext,bitIndex651) )
            & ( v6561_13__array(VarNext,A,bitIndex2)
            <=> v7034(VarNext,bitIndex650) )
            & ( v6561_13__array(VarNext,A,bitIndex1)
            <=> v7034(VarNext,bitIndex649) )
            & ( v6561_13__array(VarNext,A,bitIndex0)
            <=> v7034(VarNext,bitIndex648) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1279,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7028(VarNext)
      <=> ( v7029(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1278,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7029(VarNext)
      <=> ( v7031(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_602,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7031(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_14,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b1011_address_term = A
              & v7019(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_12__array(VarNext,A,B)
              <=> v6561_11__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_14,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b1011_address_term = A
            & v7019(VarNext) )
         => ( ( v6561_12__array(VarNext,A,bitIndex53)
            <=> v7025(VarNext,bitIndex647) )
            & ( v6561_12__array(VarNext,A,bitIndex52)
            <=> v7025(VarNext,bitIndex646) )
            & ( v6561_12__array(VarNext,A,bitIndex51)
            <=> v7025(VarNext,bitIndex645) )
            & ( v6561_12__array(VarNext,A,bitIndex50)
            <=> v7025(VarNext,bitIndex644) )
            & ( v6561_12__array(VarNext,A,bitIndex49)
            <=> v7025(VarNext,bitIndex643) )
            & ( v6561_12__array(VarNext,A,bitIndex48)
            <=> v7025(VarNext,bitIndex642) )
            & ( v6561_12__array(VarNext,A,bitIndex47)
            <=> v7025(VarNext,bitIndex641) )
            & ( v6561_12__array(VarNext,A,bitIndex46)
            <=> v7025(VarNext,bitIndex640) )
            & ( v6561_12__array(VarNext,A,bitIndex45)
            <=> v7025(VarNext,bitIndex639) )
            & ( v6561_12__array(VarNext,A,bitIndex44)
            <=> v7025(VarNext,bitIndex638) )
            & ( v6561_12__array(VarNext,A,bitIndex43)
            <=> v7025(VarNext,bitIndex637) )
            & ( v6561_12__array(VarNext,A,bitIndex42)
            <=> v7025(VarNext,bitIndex636) )
            & ( v6561_12__array(VarNext,A,bitIndex41)
            <=> v7025(VarNext,bitIndex635) )
            & ( v6561_12__array(VarNext,A,bitIndex40)
            <=> v7025(VarNext,bitIndex634) )
            & ( v6561_12__array(VarNext,A,bitIndex39)
            <=> v7025(VarNext,bitIndex633) )
            & ( v6561_12__array(VarNext,A,bitIndex38)
            <=> v7025(VarNext,bitIndex632) )
            & ( v6561_12__array(VarNext,A,bitIndex37)
            <=> v7025(VarNext,bitIndex631) )
            & ( v6561_12__array(VarNext,A,bitIndex36)
            <=> v7025(VarNext,bitIndex630) )
            & ( v6561_12__array(VarNext,A,bitIndex35)
            <=> v7025(VarNext,bitIndex629) )
            & ( v6561_12__array(VarNext,A,bitIndex34)
            <=> v7025(VarNext,bitIndex628) )
            & ( v6561_12__array(VarNext,A,bitIndex33)
            <=> v7025(VarNext,bitIndex627) )
            & ( v6561_12__array(VarNext,A,bitIndex32)
            <=> v7025(VarNext,bitIndex626) )
            & ( v6561_12__array(VarNext,A,bitIndex31)
            <=> v7025(VarNext,bitIndex625) )
            & ( v6561_12__array(VarNext,A,bitIndex30)
            <=> v7025(VarNext,bitIndex624) )
            & ( v6561_12__array(VarNext,A,bitIndex29)
            <=> v7025(VarNext,bitIndex623) )
            & ( v6561_12__array(VarNext,A,bitIndex28)
            <=> v7025(VarNext,bitIndex622) )
            & ( v6561_12__array(VarNext,A,bitIndex27)
            <=> v7025(VarNext,bitIndex621) )
            & ( v6561_12__array(VarNext,A,bitIndex26)
            <=> v7025(VarNext,bitIndex620) )
            & ( v6561_12__array(VarNext,A,bitIndex25)
            <=> v7025(VarNext,bitIndex619) )
            & ( v6561_12__array(VarNext,A,bitIndex24)
            <=> v7025(VarNext,bitIndex618) )
            & ( v6561_12__array(VarNext,A,bitIndex23)
            <=> v7025(VarNext,bitIndex617) )
            & ( v6561_12__array(VarNext,A,bitIndex22)
            <=> v7025(VarNext,bitIndex616) )
            & ( v6561_12__array(VarNext,A,bitIndex21)
            <=> v7025(VarNext,bitIndex615) )
            & ( v6561_12__array(VarNext,A,bitIndex20)
            <=> v7025(VarNext,bitIndex614) )
            & ( v6561_12__array(VarNext,A,bitIndex19)
            <=> v7025(VarNext,bitIndex613) )
            & ( v6561_12__array(VarNext,A,bitIndex18)
            <=> v7025(VarNext,bitIndex612) )
            & ( v6561_12__array(VarNext,A,bitIndex17)
            <=> v7025(VarNext,bitIndex611) )
            & ( v6561_12__array(VarNext,A,bitIndex16)
            <=> v7025(VarNext,bitIndex610) )
            & ( v6561_12__array(VarNext,A,bitIndex15)
            <=> v7025(VarNext,bitIndex609) )
            & ( v6561_12__array(VarNext,A,bitIndex14)
            <=> v7025(VarNext,bitIndex608) )
            & ( v6561_12__array(VarNext,A,bitIndex13)
            <=> v7025(VarNext,bitIndex607) )
            & ( v6561_12__array(VarNext,A,bitIndex12)
            <=> v7025(VarNext,bitIndex606) )
            & ( v6561_12__array(VarNext,A,bitIndex11)
            <=> v7025(VarNext,bitIndex605) )
            & ( v6561_12__array(VarNext,A,bitIndex10)
            <=> v7025(VarNext,bitIndex604) )
            & ( v6561_12__array(VarNext,A,bitIndex9)
            <=> v7025(VarNext,bitIndex603) )
            & ( v6561_12__array(VarNext,A,bitIndex8)
            <=> v7025(VarNext,bitIndex602) )
            & ( v6561_12__array(VarNext,A,bitIndex7)
            <=> v7025(VarNext,bitIndex601) )
            & ( v6561_12__array(VarNext,A,bitIndex6)
            <=> v7025(VarNext,bitIndex600) )
            & ( v6561_12__array(VarNext,A,bitIndex5)
            <=> v7025(VarNext,bitIndex599) )
            & ( v6561_12__array(VarNext,A,bitIndex4)
            <=> v7025(VarNext,bitIndex598) )
            & ( v6561_12__array(VarNext,A,bitIndex3)
            <=> v7025(VarNext,bitIndex597) )
            & ( v6561_12__array(VarNext,A,bitIndex2)
            <=> v7025(VarNext,bitIndex596) )
            & ( v6561_12__array(VarNext,A,bitIndex1)
            <=> v7025(VarNext,bitIndex595) )
            & ( v6561_12__array(VarNext,A,bitIndex0)
            <=> v7025(VarNext,bitIndex594) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1277,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7019(VarNext)
      <=> ( v7020(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1276,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7020(VarNext)
      <=> ( v7022(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_601,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7022(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_13,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b1010_address_term = A
              & v7010(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_11__array(VarNext,A,B)
              <=> v6561_10__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_13,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b1010_address_term = A
            & v7010(VarNext) )
         => ( ( v6561_11__array(VarNext,A,bitIndex53)
            <=> v7016(VarNext,bitIndex593) )
            & ( v6561_11__array(VarNext,A,bitIndex52)
            <=> v7016(VarNext,bitIndex592) )
            & ( v6561_11__array(VarNext,A,bitIndex51)
            <=> v7016(VarNext,bitIndex591) )
            & ( v6561_11__array(VarNext,A,bitIndex50)
            <=> v7016(VarNext,bitIndex590) )
            & ( v6561_11__array(VarNext,A,bitIndex49)
            <=> v7016(VarNext,bitIndex589) )
            & ( v6561_11__array(VarNext,A,bitIndex48)
            <=> v7016(VarNext,bitIndex588) )
            & ( v6561_11__array(VarNext,A,bitIndex47)
            <=> v7016(VarNext,bitIndex587) )
            & ( v6561_11__array(VarNext,A,bitIndex46)
            <=> v7016(VarNext,bitIndex586) )
            & ( v6561_11__array(VarNext,A,bitIndex45)
            <=> v7016(VarNext,bitIndex585) )
            & ( v6561_11__array(VarNext,A,bitIndex44)
            <=> v7016(VarNext,bitIndex584) )
            & ( v6561_11__array(VarNext,A,bitIndex43)
            <=> v7016(VarNext,bitIndex583) )
            & ( v6561_11__array(VarNext,A,bitIndex42)
            <=> v7016(VarNext,bitIndex582) )
            & ( v6561_11__array(VarNext,A,bitIndex41)
            <=> v7016(VarNext,bitIndex581) )
            & ( v6561_11__array(VarNext,A,bitIndex40)
            <=> v7016(VarNext,bitIndex580) )
            & ( v6561_11__array(VarNext,A,bitIndex39)
            <=> v7016(VarNext,bitIndex579) )
            & ( v6561_11__array(VarNext,A,bitIndex38)
            <=> v7016(VarNext,bitIndex578) )
            & ( v6561_11__array(VarNext,A,bitIndex37)
            <=> v7016(VarNext,bitIndex577) )
            & ( v6561_11__array(VarNext,A,bitIndex36)
            <=> v7016(VarNext,bitIndex576) )
            & ( v6561_11__array(VarNext,A,bitIndex35)
            <=> v7016(VarNext,bitIndex575) )
            & ( v6561_11__array(VarNext,A,bitIndex34)
            <=> v7016(VarNext,bitIndex574) )
            & ( v6561_11__array(VarNext,A,bitIndex33)
            <=> v7016(VarNext,bitIndex573) )
            & ( v6561_11__array(VarNext,A,bitIndex32)
            <=> v7016(VarNext,bitIndex572) )
            & ( v6561_11__array(VarNext,A,bitIndex31)
            <=> v7016(VarNext,bitIndex571) )
            & ( v6561_11__array(VarNext,A,bitIndex30)
            <=> v7016(VarNext,bitIndex570) )
            & ( v6561_11__array(VarNext,A,bitIndex29)
            <=> v7016(VarNext,bitIndex569) )
            & ( v6561_11__array(VarNext,A,bitIndex28)
            <=> v7016(VarNext,bitIndex568) )
            & ( v6561_11__array(VarNext,A,bitIndex27)
            <=> v7016(VarNext,bitIndex567) )
            & ( v6561_11__array(VarNext,A,bitIndex26)
            <=> v7016(VarNext,bitIndex566) )
            & ( v6561_11__array(VarNext,A,bitIndex25)
            <=> v7016(VarNext,bitIndex565) )
            & ( v6561_11__array(VarNext,A,bitIndex24)
            <=> v7016(VarNext,bitIndex564) )
            & ( v6561_11__array(VarNext,A,bitIndex23)
            <=> v7016(VarNext,bitIndex563) )
            & ( v6561_11__array(VarNext,A,bitIndex22)
            <=> v7016(VarNext,bitIndex562) )
            & ( v6561_11__array(VarNext,A,bitIndex21)
            <=> v7016(VarNext,bitIndex561) )
            & ( v6561_11__array(VarNext,A,bitIndex20)
            <=> v7016(VarNext,bitIndex560) )
            & ( v6561_11__array(VarNext,A,bitIndex19)
            <=> v7016(VarNext,bitIndex559) )
            & ( v6561_11__array(VarNext,A,bitIndex18)
            <=> v7016(VarNext,bitIndex558) )
            & ( v6561_11__array(VarNext,A,bitIndex17)
            <=> v7016(VarNext,bitIndex557) )
            & ( v6561_11__array(VarNext,A,bitIndex16)
            <=> v7016(VarNext,bitIndex556) )
            & ( v6561_11__array(VarNext,A,bitIndex15)
            <=> v7016(VarNext,bitIndex555) )
            & ( v6561_11__array(VarNext,A,bitIndex14)
            <=> v7016(VarNext,bitIndex554) )
            & ( v6561_11__array(VarNext,A,bitIndex13)
            <=> v7016(VarNext,bitIndex553) )
            & ( v6561_11__array(VarNext,A,bitIndex12)
            <=> v7016(VarNext,bitIndex552) )
            & ( v6561_11__array(VarNext,A,bitIndex11)
            <=> v7016(VarNext,bitIndex551) )
            & ( v6561_11__array(VarNext,A,bitIndex10)
            <=> v7016(VarNext,bitIndex550) )
            & ( v6561_11__array(VarNext,A,bitIndex9)
            <=> v7016(VarNext,bitIndex549) )
            & ( v6561_11__array(VarNext,A,bitIndex8)
            <=> v7016(VarNext,bitIndex548) )
            & ( v6561_11__array(VarNext,A,bitIndex7)
            <=> v7016(VarNext,bitIndex547) )
            & ( v6561_11__array(VarNext,A,bitIndex6)
            <=> v7016(VarNext,bitIndex546) )
            & ( v6561_11__array(VarNext,A,bitIndex5)
            <=> v7016(VarNext,bitIndex545) )
            & ( v6561_11__array(VarNext,A,bitIndex4)
            <=> v7016(VarNext,bitIndex544) )
            & ( v6561_11__array(VarNext,A,bitIndex3)
            <=> v7016(VarNext,bitIndex543) )
            & ( v6561_11__array(VarNext,A,bitIndex2)
            <=> v7016(VarNext,bitIndex542) )
            & ( v6561_11__array(VarNext,A,bitIndex1)
            <=> v7016(VarNext,bitIndex541) )
            & ( v6561_11__array(VarNext,A,bitIndex0)
            <=> v7016(VarNext,bitIndex540) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1275,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7010(VarNext)
      <=> ( v7011(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1274,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7011(VarNext)
      <=> ( v7013(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_600,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7013(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_12,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b1001_address_term = A
              & v7001(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_10__array(VarNext,A,B)
              <=> v6561_9__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_12,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b1001_address_term = A
            & v7001(VarNext) )
         => ( ( v6561_10__array(VarNext,A,bitIndex53)
            <=> v7007(VarNext,bitIndex539) )
            & ( v6561_10__array(VarNext,A,bitIndex52)
            <=> v7007(VarNext,bitIndex538) )
            & ( v6561_10__array(VarNext,A,bitIndex51)
            <=> v7007(VarNext,bitIndex537) )
            & ( v6561_10__array(VarNext,A,bitIndex50)
            <=> v7007(VarNext,bitIndex536) )
            & ( v6561_10__array(VarNext,A,bitIndex49)
            <=> v7007(VarNext,bitIndex535) )
            & ( v6561_10__array(VarNext,A,bitIndex48)
            <=> v7007(VarNext,bitIndex534) )
            & ( v6561_10__array(VarNext,A,bitIndex47)
            <=> v7007(VarNext,bitIndex533) )
            & ( v6561_10__array(VarNext,A,bitIndex46)
            <=> v7007(VarNext,bitIndex532) )
            & ( v6561_10__array(VarNext,A,bitIndex45)
            <=> v7007(VarNext,bitIndex531) )
            & ( v6561_10__array(VarNext,A,bitIndex44)
            <=> v7007(VarNext,bitIndex530) )
            & ( v6561_10__array(VarNext,A,bitIndex43)
            <=> v7007(VarNext,bitIndex529) )
            & ( v6561_10__array(VarNext,A,bitIndex42)
            <=> v7007(VarNext,bitIndex528) )
            & ( v6561_10__array(VarNext,A,bitIndex41)
            <=> v7007(VarNext,bitIndex527) )
            & ( v6561_10__array(VarNext,A,bitIndex40)
            <=> v7007(VarNext,bitIndex526) )
            & ( v6561_10__array(VarNext,A,bitIndex39)
            <=> v7007(VarNext,bitIndex525) )
            & ( v6561_10__array(VarNext,A,bitIndex38)
            <=> v7007(VarNext,bitIndex524) )
            & ( v6561_10__array(VarNext,A,bitIndex37)
            <=> v7007(VarNext,bitIndex523) )
            & ( v6561_10__array(VarNext,A,bitIndex36)
            <=> v7007(VarNext,bitIndex522) )
            & ( v6561_10__array(VarNext,A,bitIndex35)
            <=> v7007(VarNext,bitIndex521) )
            & ( v6561_10__array(VarNext,A,bitIndex34)
            <=> v7007(VarNext,bitIndex520) )
            & ( v6561_10__array(VarNext,A,bitIndex33)
            <=> v7007(VarNext,bitIndex519) )
            & ( v6561_10__array(VarNext,A,bitIndex32)
            <=> v7007(VarNext,bitIndex518) )
            & ( v6561_10__array(VarNext,A,bitIndex31)
            <=> v7007(VarNext,bitIndex517) )
            & ( v6561_10__array(VarNext,A,bitIndex30)
            <=> v7007(VarNext,bitIndex516) )
            & ( v6561_10__array(VarNext,A,bitIndex29)
            <=> v7007(VarNext,bitIndex515) )
            & ( v6561_10__array(VarNext,A,bitIndex28)
            <=> v7007(VarNext,bitIndex514) )
            & ( v6561_10__array(VarNext,A,bitIndex27)
            <=> v7007(VarNext,bitIndex513) )
            & ( v6561_10__array(VarNext,A,bitIndex26)
            <=> v7007(VarNext,bitIndex512) )
            & ( v6561_10__array(VarNext,A,bitIndex25)
            <=> v7007(VarNext,bitIndex511) )
            & ( v6561_10__array(VarNext,A,bitIndex24)
            <=> v7007(VarNext,bitIndex510) )
            & ( v6561_10__array(VarNext,A,bitIndex23)
            <=> v7007(VarNext,bitIndex509) )
            & ( v6561_10__array(VarNext,A,bitIndex22)
            <=> v7007(VarNext,bitIndex508) )
            & ( v6561_10__array(VarNext,A,bitIndex21)
            <=> v7007(VarNext,bitIndex507) )
            & ( v6561_10__array(VarNext,A,bitIndex20)
            <=> v7007(VarNext,bitIndex506) )
            & ( v6561_10__array(VarNext,A,bitIndex19)
            <=> v7007(VarNext,bitIndex505) )
            & ( v6561_10__array(VarNext,A,bitIndex18)
            <=> v7007(VarNext,bitIndex504) )
            & ( v6561_10__array(VarNext,A,bitIndex17)
            <=> v7007(VarNext,bitIndex503) )
            & ( v6561_10__array(VarNext,A,bitIndex16)
            <=> v7007(VarNext,bitIndex502) )
            & ( v6561_10__array(VarNext,A,bitIndex15)
            <=> v7007(VarNext,bitIndex501) )
            & ( v6561_10__array(VarNext,A,bitIndex14)
            <=> v7007(VarNext,bitIndex500) )
            & ( v6561_10__array(VarNext,A,bitIndex13)
            <=> v7007(VarNext,bitIndex499) )
            & ( v6561_10__array(VarNext,A,bitIndex12)
            <=> v7007(VarNext,bitIndex498) )
            & ( v6561_10__array(VarNext,A,bitIndex11)
            <=> v7007(VarNext,bitIndex497) )
            & ( v6561_10__array(VarNext,A,bitIndex10)
            <=> v7007(VarNext,bitIndex496) )
            & ( v6561_10__array(VarNext,A,bitIndex9)
            <=> v7007(VarNext,bitIndex495) )
            & ( v6561_10__array(VarNext,A,bitIndex8)
            <=> v7007(VarNext,bitIndex494) )
            & ( v6561_10__array(VarNext,A,bitIndex7)
            <=> v7007(VarNext,bitIndex493) )
            & ( v6561_10__array(VarNext,A,bitIndex6)
            <=> v7007(VarNext,bitIndex492) )
            & ( v6561_10__array(VarNext,A,bitIndex5)
            <=> v7007(VarNext,bitIndex491) )
            & ( v6561_10__array(VarNext,A,bitIndex4)
            <=> v7007(VarNext,bitIndex490) )
            & ( v6561_10__array(VarNext,A,bitIndex3)
            <=> v7007(VarNext,bitIndex489) )
            & ( v6561_10__array(VarNext,A,bitIndex2)
            <=> v7007(VarNext,bitIndex488) )
            & ( v6561_10__array(VarNext,A,bitIndex1)
            <=> v7007(VarNext,bitIndex487) )
            & ( v6561_10__array(VarNext,A,bitIndex0)
            <=> v7007(VarNext,bitIndex486) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1273,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7001(VarNext)
      <=> ( v7002(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1272,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v7002(VarNext)
      <=> ( v7004(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_599,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v7004(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_11,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b1000_address_term = A
              & v6992(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_9__array(VarNext,A,B)
              <=> v6561_8__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_11,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b1000_address_term = A
            & v6992(VarNext) )
         => ( ( v6561_9__array(VarNext,A,bitIndex53)
            <=> v6998(VarNext,bitIndex485) )
            & ( v6561_9__array(VarNext,A,bitIndex52)
            <=> v6998(VarNext,bitIndex484) )
            & ( v6561_9__array(VarNext,A,bitIndex51)
            <=> v6998(VarNext,bitIndex483) )
            & ( v6561_9__array(VarNext,A,bitIndex50)
            <=> v6998(VarNext,bitIndex482) )
            & ( v6561_9__array(VarNext,A,bitIndex49)
            <=> v6998(VarNext,bitIndex481) )
            & ( v6561_9__array(VarNext,A,bitIndex48)
            <=> v6998(VarNext,bitIndex480) )
            & ( v6561_9__array(VarNext,A,bitIndex47)
            <=> v6998(VarNext,bitIndex479) )
            & ( v6561_9__array(VarNext,A,bitIndex46)
            <=> v6998(VarNext,bitIndex478) )
            & ( v6561_9__array(VarNext,A,bitIndex45)
            <=> v6998(VarNext,bitIndex477) )
            & ( v6561_9__array(VarNext,A,bitIndex44)
            <=> v6998(VarNext,bitIndex476) )
            & ( v6561_9__array(VarNext,A,bitIndex43)
            <=> v6998(VarNext,bitIndex475) )
            & ( v6561_9__array(VarNext,A,bitIndex42)
            <=> v6998(VarNext,bitIndex474) )
            & ( v6561_9__array(VarNext,A,bitIndex41)
            <=> v6998(VarNext,bitIndex473) )
            & ( v6561_9__array(VarNext,A,bitIndex40)
            <=> v6998(VarNext,bitIndex472) )
            & ( v6561_9__array(VarNext,A,bitIndex39)
            <=> v6998(VarNext,bitIndex471) )
            & ( v6561_9__array(VarNext,A,bitIndex38)
            <=> v6998(VarNext,bitIndex470) )
            & ( v6561_9__array(VarNext,A,bitIndex37)
            <=> v6998(VarNext,bitIndex469) )
            & ( v6561_9__array(VarNext,A,bitIndex36)
            <=> v6998(VarNext,bitIndex468) )
            & ( v6561_9__array(VarNext,A,bitIndex35)
            <=> v6998(VarNext,bitIndex467) )
            & ( v6561_9__array(VarNext,A,bitIndex34)
            <=> v6998(VarNext,bitIndex466) )
            & ( v6561_9__array(VarNext,A,bitIndex33)
            <=> v6998(VarNext,bitIndex465) )
            & ( v6561_9__array(VarNext,A,bitIndex32)
            <=> v6998(VarNext,bitIndex464) )
            & ( v6561_9__array(VarNext,A,bitIndex31)
            <=> v6998(VarNext,bitIndex463) )
            & ( v6561_9__array(VarNext,A,bitIndex30)
            <=> v6998(VarNext,bitIndex462) )
            & ( v6561_9__array(VarNext,A,bitIndex29)
            <=> v6998(VarNext,bitIndex461) )
            & ( v6561_9__array(VarNext,A,bitIndex28)
            <=> v6998(VarNext,bitIndex460) )
            & ( v6561_9__array(VarNext,A,bitIndex27)
            <=> v6998(VarNext,bitIndex459) )
            & ( v6561_9__array(VarNext,A,bitIndex26)
            <=> v6998(VarNext,bitIndex458) )
            & ( v6561_9__array(VarNext,A,bitIndex25)
            <=> v6998(VarNext,bitIndex457) )
            & ( v6561_9__array(VarNext,A,bitIndex24)
            <=> v6998(VarNext,bitIndex456) )
            & ( v6561_9__array(VarNext,A,bitIndex23)
            <=> v6998(VarNext,bitIndex455) )
            & ( v6561_9__array(VarNext,A,bitIndex22)
            <=> v6998(VarNext,bitIndex454) )
            & ( v6561_9__array(VarNext,A,bitIndex21)
            <=> v6998(VarNext,bitIndex453) )
            & ( v6561_9__array(VarNext,A,bitIndex20)
            <=> v6998(VarNext,bitIndex452) )
            & ( v6561_9__array(VarNext,A,bitIndex19)
            <=> v6998(VarNext,bitIndex451) )
            & ( v6561_9__array(VarNext,A,bitIndex18)
            <=> v6998(VarNext,bitIndex450) )
            & ( v6561_9__array(VarNext,A,bitIndex17)
            <=> v6998(VarNext,bitIndex449) )
            & ( v6561_9__array(VarNext,A,bitIndex16)
            <=> v6998(VarNext,bitIndex448) )
            & ( v6561_9__array(VarNext,A,bitIndex15)
            <=> v6998(VarNext,bitIndex447) )
            & ( v6561_9__array(VarNext,A,bitIndex14)
            <=> v6998(VarNext,bitIndex446) )
            & ( v6561_9__array(VarNext,A,bitIndex13)
            <=> v6998(VarNext,bitIndex445) )
            & ( v6561_9__array(VarNext,A,bitIndex12)
            <=> v6998(VarNext,bitIndex444) )
            & ( v6561_9__array(VarNext,A,bitIndex11)
            <=> v6998(VarNext,bitIndex443) )
            & ( v6561_9__array(VarNext,A,bitIndex10)
            <=> v6998(VarNext,bitIndex442) )
            & ( v6561_9__array(VarNext,A,bitIndex9)
            <=> v6998(VarNext,bitIndex441) )
            & ( v6561_9__array(VarNext,A,bitIndex8)
            <=> v6998(VarNext,bitIndex440) )
            & ( v6561_9__array(VarNext,A,bitIndex7)
            <=> v6998(VarNext,bitIndex439) )
            & ( v6561_9__array(VarNext,A,bitIndex6)
            <=> v6998(VarNext,bitIndex438) )
            & ( v6561_9__array(VarNext,A,bitIndex5)
            <=> v6998(VarNext,bitIndex437) )
            & ( v6561_9__array(VarNext,A,bitIndex4)
            <=> v6998(VarNext,bitIndex436) )
            & ( v6561_9__array(VarNext,A,bitIndex3)
            <=> v6998(VarNext,bitIndex435) )
            & ( v6561_9__array(VarNext,A,bitIndex2)
            <=> v6998(VarNext,bitIndex434) )
            & ( v6561_9__array(VarNext,A,bitIndex1)
            <=> v6998(VarNext,bitIndex433) )
            & ( v6561_9__array(VarNext,A,bitIndex0)
            <=> v6998(VarNext,bitIndex432) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1271,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6992(VarNext)
      <=> ( v6993(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1270,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6993(VarNext)
      <=> ( v6995(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_598,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6995(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_10,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b0111_address_term = A
              & v6983(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_8__array(VarNext,A,B)
              <=> v6561_7__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_10,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b0111_address_term = A
            & v6983(VarNext) )
         => ( ( v6561_8__array(VarNext,A,bitIndex53)
            <=> v6989(VarNext,bitIndex431) )
            & ( v6561_8__array(VarNext,A,bitIndex52)
            <=> v6989(VarNext,bitIndex430) )
            & ( v6561_8__array(VarNext,A,bitIndex51)
            <=> v6989(VarNext,bitIndex429) )
            & ( v6561_8__array(VarNext,A,bitIndex50)
            <=> v6989(VarNext,bitIndex428) )
            & ( v6561_8__array(VarNext,A,bitIndex49)
            <=> v6989(VarNext,bitIndex427) )
            & ( v6561_8__array(VarNext,A,bitIndex48)
            <=> v6989(VarNext,bitIndex426) )
            & ( v6561_8__array(VarNext,A,bitIndex47)
            <=> v6989(VarNext,bitIndex425) )
            & ( v6561_8__array(VarNext,A,bitIndex46)
            <=> v6989(VarNext,bitIndex424) )
            & ( v6561_8__array(VarNext,A,bitIndex45)
            <=> v6989(VarNext,bitIndex423) )
            & ( v6561_8__array(VarNext,A,bitIndex44)
            <=> v6989(VarNext,bitIndex422) )
            & ( v6561_8__array(VarNext,A,bitIndex43)
            <=> v6989(VarNext,bitIndex421) )
            & ( v6561_8__array(VarNext,A,bitIndex42)
            <=> v6989(VarNext,bitIndex420) )
            & ( v6561_8__array(VarNext,A,bitIndex41)
            <=> v6989(VarNext,bitIndex419) )
            & ( v6561_8__array(VarNext,A,bitIndex40)
            <=> v6989(VarNext,bitIndex418) )
            & ( v6561_8__array(VarNext,A,bitIndex39)
            <=> v6989(VarNext,bitIndex417) )
            & ( v6561_8__array(VarNext,A,bitIndex38)
            <=> v6989(VarNext,bitIndex416) )
            & ( v6561_8__array(VarNext,A,bitIndex37)
            <=> v6989(VarNext,bitIndex415) )
            & ( v6561_8__array(VarNext,A,bitIndex36)
            <=> v6989(VarNext,bitIndex414) )
            & ( v6561_8__array(VarNext,A,bitIndex35)
            <=> v6989(VarNext,bitIndex413) )
            & ( v6561_8__array(VarNext,A,bitIndex34)
            <=> v6989(VarNext,bitIndex412) )
            & ( v6561_8__array(VarNext,A,bitIndex33)
            <=> v6989(VarNext,bitIndex411) )
            & ( v6561_8__array(VarNext,A,bitIndex32)
            <=> v6989(VarNext,bitIndex410) )
            & ( v6561_8__array(VarNext,A,bitIndex31)
            <=> v6989(VarNext,bitIndex409) )
            & ( v6561_8__array(VarNext,A,bitIndex30)
            <=> v6989(VarNext,bitIndex408) )
            & ( v6561_8__array(VarNext,A,bitIndex29)
            <=> v6989(VarNext,bitIndex407) )
            & ( v6561_8__array(VarNext,A,bitIndex28)
            <=> v6989(VarNext,bitIndex406) )
            & ( v6561_8__array(VarNext,A,bitIndex27)
            <=> v6989(VarNext,bitIndex405) )
            & ( v6561_8__array(VarNext,A,bitIndex26)
            <=> v6989(VarNext,bitIndex404) )
            & ( v6561_8__array(VarNext,A,bitIndex25)
            <=> v6989(VarNext,bitIndex403) )
            & ( v6561_8__array(VarNext,A,bitIndex24)
            <=> v6989(VarNext,bitIndex402) )
            & ( v6561_8__array(VarNext,A,bitIndex23)
            <=> v6989(VarNext,bitIndex401) )
            & ( v6561_8__array(VarNext,A,bitIndex22)
            <=> v6989(VarNext,bitIndex400) )
            & ( v6561_8__array(VarNext,A,bitIndex21)
            <=> v6989(VarNext,bitIndex399) )
            & ( v6561_8__array(VarNext,A,bitIndex20)
            <=> v6989(VarNext,bitIndex398) )
            & ( v6561_8__array(VarNext,A,bitIndex19)
            <=> v6989(VarNext,bitIndex397) )
            & ( v6561_8__array(VarNext,A,bitIndex18)
            <=> v6989(VarNext,bitIndex396) )
            & ( v6561_8__array(VarNext,A,bitIndex17)
            <=> v6989(VarNext,bitIndex395) )
            & ( v6561_8__array(VarNext,A,bitIndex16)
            <=> v6989(VarNext,bitIndex394) )
            & ( v6561_8__array(VarNext,A,bitIndex15)
            <=> v6989(VarNext,bitIndex393) )
            & ( v6561_8__array(VarNext,A,bitIndex14)
            <=> v6989(VarNext,bitIndex392) )
            & ( v6561_8__array(VarNext,A,bitIndex13)
            <=> v6989(VarNext,bitIndex391) )
            & ( v6561_8__array(VarNext,A,bitIndex12)
            <=> v6989(VarNext,bitIndex390) )
            & ( v6561_8__array(VarNext,A,bitIndex11)
            <=> v6989(VarNext,bitIndex389) )
            & ( v6561_8__array(VarNext,A,bitIndex10)
            <=> v6989(VarNext,bitIndex388) )
            & ( v6561_8__array(VarNext,A,bitIndex9)
            <=> v6989(VarNext,bitIndex387) )
            & ( v6561_8__array(VarNext,A,bitIndex8)
            <=> v6989(VarNext,bitIndex386) )
            & ( v6561_8__array(VarNext,A,bitIndex7)
            <=> v6989(VarNext,bitIndex385) )
            & ( v6561_8__array(VarNext,A,bitIndex6)
            <=> v6989(VarNext,bitIndex384) )
            & ( v6561_8__array(VarNext,A,bitIndex5)
            <=> v6989(VarNext,bitIndex383) )
            & ( v6561_8__array(VarNext,A,bitIndex4)
            <=> v6989(VarNext,bitIndex382) )
            & ( v6561_8__array(VarNext,A,bitIndex3)
            <=> v6989(VarNext,bitIndex381) )
            & ( v6561_8__array(VarNext,A,bitIndex2)
            <=> v6989(VarNext,bitIndex380) )
            & ( v6561_8__array(VarNext,A,bitIndex1)
            <=> v6989(VarNext,bitIndex379) )
            & ( v6561_8__array(VarNext,A,bitIndex0)
            <=> v6989(VarNext,bitIndex378) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1269,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6983(VarNext)
      <=> ( v6984(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1268,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6984(VarNext)
      <=> ( v6986(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_597,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6986(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_9,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b0110_address_term = A
              & v6974(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_7__array(VarNext,A,B)
              <=> v6561_6__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_9,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b0110_address_term = A
            & v6974(VarNext) )
         => ( ( v6561_7__array(VarNext,A,bitIndex53)
            <=> v6980(VarNext,bitIndex377) )
            & ( v6561_7__array(VarNext,A,bitIndex52)
            <=> v6980(VarNext,bitIndex376) )
            & ( v6561_7__array(VarNext,A,bitIndex51)
            <=> v6980(VarNext,bitIndex375) )
            & ( v6561_7__array(VarNext,A,bitIndex50)
            <=> v6980(VarNext,bitIndex374) )
            & ( v6561_7__array(VarNext,A,bitIndex49)
            <=> v6980(VarNext,bitIndex373) )
            & ( v6561_7__array(VarNext,A,bitIndex48)
            <=> v6980(VarNext,bitIndex372) )
            & ( v6561_7__array(VarNext,A,bitIndex47)
            <=> v6980(VarNext,bitIndex371) )
            & ( v6561_7__array(VarNext,A,bitIndex46)
            <=> v6980(VarNext,bitIndex370) )
            & ( v6561_7__array(VarNext,A,bitIndex45)
            <=> v6980(VarNext,bitIndex369) )
            & ( v6561_7__array(VarNext,A,bitIndex44)
            <=> v6980(VarNext,bitIndex368) )
            & ( v6561_7__array(VarNext,A,bitIndex43)
            <=> v6980(VarNext,bitIndex367) )
            & ( v6561_7__array(VarNext,A,bitIndex42)
            <=> v6980(VarNext,bitIndex366) )
            & ( v6561_7__array(VarNext,A,bitIndex41)
            <=> v6980(VarNext,bitIndex365) )
            & ( v6561_7__array(VarNext,A,bitIndex40)
            <=> v6980(VarNext,bitIndex364) )
            & ( v6561_7__array(VarNext,A,bitIndex39)
            <=> v6980(VarNext,bitIndex363) )
            & ( v6561_7__array(VarNext,A,bitIndex38)
            <=> v6980(VarNext,bitIndex362) )
            & ( v6561_7__array(VarNext,A,bitIndex37)
            <=> v6980(VarNext,bitIndex361) )
            & ( v6561_7__array(VarNext,A,bitIndex36)
            <=> v6980(VarNext,bitIndex360) )
            & ( v6561_7__array(VarNext,A,bitIndex35)
            <=> v6980(VarNext,bitIndex359) )
            & ( v6561_7__array(VarNext,A,bitIndex34)
            <=> v6980(VarNext,bitIndex358) )
            & ( v6561_7__array(VarNext,A,bitIndex33)
            <=> v6980(VarNext,bitIndex357) )
            & ( v6561_7__array(VarNext,A,bitIndex32)
            <=> v6980(VarNext,bitIndex356) )
            & ( v6561_7__array(VarNext,A,bitIndex31)
            <=> v6980(VarNext,bitIndex355) )
            & ( v6561_7__array(VarNext,A,bitIndex30)
            <=> v6980(VarNext,bitIndex354) )
            & ( v6561_7__array(VarNext,A,bitIndex29)
            <=> v6980(VarNext,bitIndex353) )
            & ( v6561_7__array(VarNext,A,bitIndex28)
            <=> v6980(VarNext,bitIndex352) )
            & ( v6561_7__array(VarNext,A,bitIndex27)
            <=> v6980(VarNext,bitIndex351) )
            & ( v6561_7__array(VarNext,A,bitIndex26)
            <=> v6980(VarNext,bitIndex350) )
            & ( v6561_7__array(VarNext,A,bitIndex25)
            <=> v6980(VarNext,bitIndex349) )
            & ( v6561_7__array(VarNext,A,bitIndex24)
            <=> v6980(VarNext,bitIndex348) )
            & ( v6561_7__array(VarNext,A,bitIndex23)
            <=> v6980(VarNext,bitIndex347) )
            & ( v6561_7__array(VarNext,A,bitIndex22)
            <=> v6980(VarNext,bitIndex346) )
            & ( v6561_7__array(VarNext,A,bitIndex21)
            <=> v6980(VarNext,bitIndex345) )
            & ( v6561_7__array(VarNext,A,bitIndex20)
            <=> v6980(VarNext,bitIndex344) )
            & ( v6561_7__array(VarNext,A,bitIndex19)
            <=> v6980(VarNext,bitIndex343) )
            & ( v6561_7__array(VarNext,A,bitIndex18)
            <=> v6980(VarNext,bitIndex342) )
            & ( v6561_7__array(VarNext,A,bitIndex17)
            <=> v6980(VarNext,bitIndex341) )
            & ( v6561_7__array(VarNext,A,bitIndex16)
            <=> v6980(VarNext,bitIndex340) )
            & ( v6561_7__array(VarNext,A,bitIndex15)
            <=> v6980(VarNext,bitIndex339) )
            & ( v6561_7__array(VarNext,A,bitIndex14)
            <=> v6980(VarNext,bitIndex338) )
            & ( v6561_7__array(VarNext,A,bitIndex13)
            <=> v6980(VarNext,bitIndex337) )
            & ( v6561_7__array(VarNext,A,bitIndex12)
            <=> v6980(VarNext,bitIndex336) )
            & ( v6561_7__array(VarNext,A,bitIndex11)
            <=> v6980(VarNext,bitIndex335) )
            & ( v6561_7__array(VarNext,A,bitIndex10)
            <=> v6980(VarNext,bitIndex334) )
            & ( v6561_7__array(VarNext,A,bitIndex9)
            <=> v6980(VarNext,bitIndex333) )
            & ( v6561_7__array(VarNext,A,bitIndex8)
            <=> v6980(VarNext,bitIndex332) )
            & ( v6561_7__array(VarNext,A,bitIndex7)
            <=> v6980(VarNext,bitIndex331) )
            & ( v6561_7__array(VarNext,A,bitIndex6)
            <=> v6980(VarNext,bitIndex330) )
            & ( v6561_7__array(VarNext,A,bitIndex5)
            <=> v6980(VarNext,bitIndex329) )
            & ( v6561_7__array(VarNext,A,bitIndex4)
            <=> v6980(VarNext,bitIndex328) )
            & ( v6561_7__array(VarNext,A,bitIndex3)
            <=> v6980(VarNext,bitIndex327) )
            & ( v6561_7__array(VarNext,A,bitIndex2)
            <=> v6980(VarNext,bitIndex326) )
            & ( v6561_7__array(VarNext,A,bitIndex1)
            <=> v6980(VarNext,bitIndex325) )
            & ( v6561_7__array(VarNext,A,bitIndex0)
            <=> v6980(VarNext,bitIndex324) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1267,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6974(VarNext)
      <=> ( v6975(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1266,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6975(VarNext)
      <=> ( v6977(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_596,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6977(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_8,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b0101_address_term = A
              & v6965(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_6__array(VarNext,A,B)
              <=> v6561_5__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_8,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b0101_address_term = A
            & v6965(VarNext) )
         => ( ( v6561_6__array(VarNext,A,bitIndex53)
            <=> v6971(VarNext,bitIndex323) )
            & ( v6561_6__array(VarNext,A,bitIndex52)
            <=> v6971(VarNext,bitIndex322) )
            & ( v6561_6__array(VarNext,A,bitIndex51)
            <=> v6971(VarNext,bitIndex321) )
            & ( v6561_6__array(VarNext,A,bitIndex50)
            <=> v6971(VarNext,bitIndex320) )
            & ( v6561_6__array(VarNext,A,bitIndex49)
            <=> v6971(VarNext,bitIndex319) )
            & ( v6561_6__array(VarNext,A,bitIndex48)
            <=> v6971(VarNext,bitIndex318) )
            & ( v6561_6__array(VarNext,A,bitIndex47)
            <=> v6971(VarNext,bitIndex317) )
            & ( v6561_6__array(VarNext,A,bitIndex46)
            <=> v6971(VarNext,bitIndex316) )
            & ( v6561_6__array(VarNext,A,bitIndex45)
            <=> v6971(VarNext,bitIndex315) )
            & ( v6561_6__array(VarNext,A,bitIndex44)
            <=> v6971(VarNext,bitIndex314) )
            & ( v6561_6__array(VarNext,A,bitIndex43)
            <=> v6971(VarNext,bitIndex313) )
            & ( v6561_6__array(VarNext,A,bitIndex42)
            <=> v6971(VarNext,bitIndex312) )
            & ( v6561_6__array(VarNext,A,bitIndex41)
            <=> v6971(VarNext,bitIndex311) )
            & ( v6561_6__array(VarNext,A,bitIndex40)
            <=> v6971(VarNext,bitIndex310) )
            & ( v6561_6__array(VarNext,A,bitIndex39)
            <=> v6971(VarNext,bitIndex309) )
            & ( v6561_6__array(VarNext,A,bitIndex38)
            <=> v6971(VarNext,bitIndex308) )
            & ( v6561_6__array(VarNext,A,bitIndex37)
            <=> v6971(VarNext,bitIndex307) )
            & ( v6561_6__array(VarNext,A,bitIndex36)
            <=> v6971(VarNext,bitIndex306) )
            & ( v6561_6__array(VarNext,A,bitIndex35)
            <=> v6971(VarNext,bitIndex305) )
            & ( v6561_6__array(VarNext,A,bitIndex34)
            <=> v6971(VarNext,bitIndex304) )
            & ( v6561_6__array(VarNext,A,bitIndex33)
            <=> v6971(VarNext,bitIndex303) )
            & ( v6561_6__array(VarNext,A,bitIndex32)
            <=> v6971(VarNext,bitIndex302) )
            & ( v6561_6__array(VarNext,A,bitIndex31)
            <=> v6971(VarNext,bitIndex301) )
            & ( v6561_6__array(VarNext,A,bitIndex30)
            <=> v6971(VarNext,bitIndex300) )
            & ( v6561_6__array(VarNext,A,bitIndex29)
            <=> v6971(VarNext,bitIndex299) )
            & ( v6561_6__array(VarNext,A,bitIndex28)
            <=> v6971(VarNext,bitIndex298) )
            & ( v6561_6__array(VarNext,A,bitIndex27)
            <=> v6971(VarNext,bitIndex297) )
            & ( v6561_6__array(VarNext,A,bitIndex26)
            <=> v6971(VarNext,bitIndex296) )
            & ( v6561_6__array(VarNext,A,bitIndex25)
            <=> v6971(VarNext,bitIndex295) )
            & ( v6561_6__array(VarNext,A,bitIndex24)
            <=> v6971(VarNext,bitIndex294) )
            & ( v6561_6__array(VarNext,A,bitIndex23)
            <=> v6971(VarNext,bitIndex293) )
            & ( v6561_6__array(VarNext,A,bitIndex22)
            <=> v6971(VarNext,bitIndex292) )
            & ( v6561_6__array(VarNext,A,bitIndex21)
            <=> v6971(VarNext,bitIndex291) )
            & ( v6561_6__array(VarNext,A,bitIndex20)
            <=> v6971(VarNext,bitIndex290) )
            & ( v6561_6__array(VarNext,A,bitIndex19)
            <=> v6971(VarNext,bitIndex289) )
            & ( v6561_6__array(VarNext,A,bitIndex18)
            <=> v6971(VarNext,bitIndex288) )
            & ( v6561_6__array(VarNext,A,bitIndex17)
            <=> v6971(VarNext,bitIndex287) )
            & ( v6561_6__array(VarNext,A,bitIndex16)
            <=> v6971(VarNext,bitIndex286) )
            & ( v6561_6__array(VarNext,A,bitIndex15)
            <=> v6971(VarNext,bitIndex285) )
            & ( v6561_6__array(VarNext,A,bitIndex14)
            <=> v6971(VarNext,bitIndex284) )
            & ( v6561_6__array(VarNext,A,bitIndex13)
            <=> v6971(VarNext,bitIndex283) )
            & ( v6561_6__array(VarNext,A,bitIndex12)
            <=> v6971(VarNext,bitIndex282) )
            & ( v6561_6__array(VarNext,A,bitIndex11)
            <=> v6971(VarNext,bitIndex281) )
            & ( v6561_6__array(VarNext,A,bitIndex10)
            <=> v6971(VarNext,bitIndex280) )
            & ( v6561_6__array(VarNext,A,bitIndex9)
            <=> v6971(VarNext,bitIndex279) )
            & ( v6561_6__array(VarNext,A,bitIndex8)
            <=> v6971(VarNext,bitIndex278) )
            & ( v6561_6__array(VarNext,A,bitIndex7)
            <=> v6971(VarNext,bitIndex277) )
            & ( v6561_6__array(VarNext,A,bitIndex6)
            <=> v6971(VarNext,bitIndex276) )
            & ( v6561_6__array(VarNext,A,bitIndex5)
            <=> v6971(VarNext,bitIndex275) )
            & ( v6561_6__array(VarNext,A,bitIndex4)
            <=> v6971(VarNext,bitIndex274) )
            & ( v6561_6__array(VarNext,A,bitIndex3)
            <=> v6971(VarNext,bitIndex273) )
            & ( v6561_6__array(VarNext,A,bitIndex2)
            <=> v6971(VarNext,bitIndex272) )
            & ( v6561_6__array(VarNext,A,bitIndex1)
            <=> v6971(VarNext,bitIndex271) )
            & ( v6561_6__array(VarNext,A,bitIndex0)
            <=> v6971(VarNext,bitIndex270) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1265,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6965(VarNext)
      <=> ( v6966(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1264,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6966(VarNext)
      <=> ( v6968(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_595,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6968(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_7,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b0100_address_term = A
              & v6956(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_5__array(VarNext,A,B)
              <=> v6561_4__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_7,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b0100_address_term = A
            & v6956(VarNext) )
         => ( ( v6561_5__array(VarNext,A,bitIndex53)
            <=> v6962(VarNext,bitIndex269) )
            & ( v6561_5__array(VarNext,A,bitIndex52)
            <=> v6962(VarNext,bitIndex268) )
            & ( v6561_5__array(VarNext,A,bitIndex51)
            <=> v6962(VarNext,bitIndex267) )
            & ( v6561_5__array(VarNext,A,bitIndex50)
            <=> v6962(VarNext,bitIndex266) )
            & ( v6561_5__array(VarNext,A,bitIndex49)
            <=> v6962(VarNext,bitIndex265) )
            & ( v6561_5__array(VarNext,A,bitIndex48)
            <=> v6962(VarNext,bitIndex264) )
            & ( v6561_5__array(VarNext,A,bitIndex47)
            <=> v6962(VarNext,bitIndex263) )
            & ( v6561_5__array(VarNext,A,bitIndex46)
            <=> v6962(VarNext,bitIndex262) )
            & ( v6561_5__array(VarNext,A,bitIndex45)
            <=> v6962(VarNext,bitIndex261) )
            & ( v6561_5__array(VarNext,A,bitIndex44)
            <=> v6962(VarNext,bitIndex260) )
            & ( v6561_5__array(VarNext,A,bitIndex43)
            <=> v6962(VarNext,bitIndex259) )
            & ( v6561_5__array(VarNext,A,bitIndex42)
            <=> v6962(VarNext,bitIndex258) )
            & ( v6561_5__array(VarNext,A,bitIndex41)
            <=> v6962(VarNext,bitIndex257) )
            & ( v6561_5__array(VarNext,A,bitIndex40)
            <=> v6962(VarNext,bitIndex256) )
            & ( v6561_5__array(VarNext,A,bitIndex39)
            <=> v6962(VarNext,bitIndex255) )
            & ( v6561_5__array(VarNext,A,bitIndex38)
            <=> v6962(VarNext,bitIndex254) )
            & ( v6561_5__array(VarNext,A,bitIndex37)
            <=> v6962(VarNext,bitIndex253) )
            & ( v6561_5__array(VarNext,A,bitIndex36)
            <=> v6962(VarNext,bitIndex252) )
            & ( v6561_5__array(VarNext,A,bitIndex35)
            <=> v6962(VarNext,bitIndex251) )
            & ( v6561_5__array(VarNext,A,bitIndex34)
            <=> v6962(VarNext,bitIndex250) )
            & ( v6561_5__array(VarNext,A,bitIndex33)
            <=> v6962(VarNext,bitIndex249) )
            & ( v6561_5__array(VarNext,A,bitIndex32)
            <=> v6962(VarNext,bitIndex248) )
            & ( v6561_5__array(VarNext,A,bitIndex31)
            <=> v6962(VarNext,bitIndex247) )
            & ( v6561_5__array(VarNext,A,bitIndex30)
            <=> v6962(VarNext,bitIndex246) )
            & ( v6561_5__array(VarNext,A,bitIndex29)
            <=> v6962(VarNext,bitIndex245) )
            & ( v6561_5__array(VarNext,A,bitIndex28)
            <=> v6962(VarNext,bitIndex244) )
            & ( v6561_5__array(VarNext,A,bitIndex27)
            <=> v6962(VarNext,bitIndex243) )
            & ( v6561_5__array(VarNext,A,bitIndex26)
            <=> v6962(VarNext,bitIndex242) )
            & ( v6561_5__array(VarNext,A,bitIndex25)
            <=> v6962(VarNext,bitIndex241) )
            & ( v6561_5__array(VarNext,A,bitIndex24)
            <=> v6962(VarNext,bitIndex240) )
            & ( v6561_5__array(VarNext,A,bitIndex23)
            <=> v6962(VarNext,bitIndex239) )
            & ( v6561_5__array(VarNext,A,bitIndex22)
            <=> v6962(VarNext,bitIndex238) )
            & ( v6561_5__array(VarNext,A,bitIndex21)
            <=> v6962(VarNext,bitIndex237) )
            & ( v6561_5__array(VarNext,A,bitIndex20)
            <=> v6962(VarNext,bitIndex236) )
            & ( v6561_5__array(VarNext,A,bitIndex19)
            <=> v6962(VarNext,bitIndex235) )
            & ( v6561_5__array(VarNext,A,bitIndex18)
            <=> v6962(VarNext,bitIndex234) )
            & ( v6561_5__array(VarNext,A,bitIndex17)
            <=> v6962(VarNext,bitIndex233) )
            & ( v6561_5__array(VarNext,A,bitIndex16)
            <=> v6962(VarNext,bitIndex232) )
            & ( v6561_5__array(VarNext,A,bitIndex15)
            <=> v6962(VarNext,bitIndex231) )
            & ( v6561_5__array(VarNext,A,bitIndex14)
            <=> v6962(VarNext,bitIndex230) )
            & ( v6561_5__array(VarNext,A,bitIndex13)
            <=> v6962(VarNext,bitIndex229) )
            & ( v6561_5__array(VarNext,A,bitIndex12)
            <=> v6962(VarNext,bitIndex228) )
            & ( v6561_5__array(VarNext,A,bitIndex11)
            <=> v6962(VarNext,bitIndex227) )
            & ( v6561_5__array(VarNext,A,bitIndex10)
            <=> v6962(VarNext,bitIndex226) )
            & ( v6561_5__array(VarNext,A,bitIndex9)
            <=> v6962(VarNext,bitIndex225) )
            & ( v6561_5__array(VarNext,A,bitIndex8)
            <=> v6962(VarNext,bitIndex224) )
            & ( v6561_5__array(VarNext,A,bitIndex7)
            <=> v6962(VarNext,bitIndex223) )
            & ( v6561_5__array(VarNext,A,bitIndex6)
            <=> v6962(VarNext,bitIndex222) )
            & ( v6561_5__array(VarNext,A,bitIndex5)
            <=> v6962(VarNext,bitIndex221) )
            & ( v6561_5__array(VarNext,A,bitIndex4)
            <=> v6962(VarNext,bitIndex220) )
            & ( v6561_5__array(VarNext,A,bitIndex3)
            <=> v6962(VarNext,bitIndex219) )
            & ( v6561_5__array(VarNext,A,bitIndex2)
            <=> v6962(VarNext,bitIndex218) )
            & ( v6561_5__array(VarNext,A,bitIndex1)
            <=> v6962(VarNext,bitIndex217) )
            & ( v6561_5__array(VarNext,A,bitIndex0)
            <=> v6962(VarNext,bitIndex216) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1263,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6956(VarNext)
      <=> ( v6957(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1262,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6957(VarNext)
      <=> ( v6959(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_594,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6959(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_6,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b0011_address_term = A
              & v6947(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_4__array(VarNext,A,B)
              <=> v6561_3__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_6,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b0011_address_term = A
            & v6947(VarNext) )
         => ( ( v6561_4__array(VarNext,A,bitIndex53)
            <=> v6953(VarNext,bitIndex215) )
            & ( v6561_4__array(VarNext,A,bitIndex52)
            <=> v6953(VarNext,bitIndex214) )
            & ( v6561_4__array(VarNext,A,bitIndex51)
            <=> v6953(VarNext,bitIndex213) )
            & ( v6561_4__array(VarNext,A,bitIndex50)
            <=> v6953(VarNext,bitIndex212) )
            & ( v6561_4__array(VarNext,A,bitIndex49)
            <=> v6953(VarNext,bitIndex211) )
            & ( v6561_4__array(VarNext,A,bitIndex48)
            <=> v6953(VarNext,bitIndex210) )
            & ( v6561_4__array(VarNext,A,bitIndex47)
            <=> v6953(VarNext,bitIndex209) )
            & ( v6561_4__array(VarNext,A,bitIndex46)
            <=> v6953(VarNext,bitIndex208) )
            & ( v6561_4__array(VarNext,A,bitIndex45)
            <=> v6953(VarNext,bitIndex207) )
            & ( v6561_4__array(VarNext,A,bitIndex44)
            <=> v6953(VarNext,bitIndex206) )
            & ( v6561_4__array(VarNext,A,bitIndex43)
            <=> v6953(VarNext,bitIndex205) )
            & ( v6561_4__array(VarNext,A,bitIndex42)
            <=> v6953(VarNext,bitIndex204) )
            & ( v6561_4__array(VarNext,A,bitIndex41)
            <=> v6953(VarNext,bitIndex203) )
            & ( v6561_4__array(VarNext,A,bitIndex40)
            <=> v6953(VarNext,bitIndex202) )
            & ( v6561_4__array(VarNext,A,bitIndex39)
            <=> v6953(VarNext,bitIndex201) )
            & ( v6561_4__array(VarNext,A,bitIndex38)
            <=> v6953(VarNext,bitIndex200) )
            & ( v6561_4__array(VarNext,A,bitIndex37)
            <=> v6953(VarNext,bitIndex199) )
            & ( v6561_4__array(VarNext,A,bitIndex36)
            <=> v6953(VarNext,bitIndex198) )
            & ( v6561_4__array(VarNext,A,bitIndex35)
            <=> v6953(VarNext,bitIndex197) )
            & ( v6561_4__array(VarNext,A,bitIndex34)
            <=> v6953(VarNext,bitIndex196) )
            & ( v6561_4__array(VarNext,A,bitIndex33)
            <=> v6953(VarNext,bitIndex195) )
            & ( v6561_4__array(VarNext,A,bitIndex32)
            <=> v6953(VarNext,bitIndex194) )
            & ( v6561_4__array(VarNext,A,bitIndex31)
            <=> v6953(VarNext,bitIndex193) )
            & ( v6561_4__array(VarNext,A,bitIndex30)
            <=> v6953(VarNext,bitIndex192) )
            & ( v6561_4__array(VarNext,A,bitIndex29)
            <=> v6953(VarNext,bitIndex191) )
            & ( v6561_4__array(VarNext,A,bitIndex28)
            <=> v6953(VarNext,bitIndex190) )
            & ( v6561_4__array(VarNext,A,bitIndex27)
            <=> v6953(VarNext,bitIndex189) )
            & ( v6561_4__array(VarNext,A,bitIndex26)
            <=> v6953(VarNext,bitIndex188) )
            & ( v6561_4__array(VarNext,A,bitIndex25)
            <=> v6953(VarNext,bitIndex187) )
            & ( v6561_4__array(VarNext,A,bitIndex24)
            <=> v6953(VarNext,bitIndex186) )
            & ( v6561_4__array(VarNext,A,bitIndex23)
            <=> v6953(VarNext,bitIndex185) )
            & ( v6561_4__array(VarNext,A,bitIndex22)
            <=> v6953(VarNext,bitIndex184) )
            & ( v6561_4__array(VarNext,A,bitIndex21)
            <=> v6953(VarNext,bitIndex183) )
            & ( v6561_4__array(VarNext,A,bitIndex20)
            <=> v6953(VarNext,bitIndex182) )
            & ( v6561_4__array(VarNext,A,bitIndex19)
            <=> v6953(VarNext,bitIndex181) )
            & ( v6561_4__array(VarNext,A,bitIndex18)
            <=> v6953(VarNext,bitIndex180) )
            & ( v6561_4__array(VarNext,A,bitIndex17)
            <=> v6953(VarNext,bitIndex179) )
            & ( v6561_4__array(VarNext,A,bitIndex16)
            <=> v6953(VarNext,bitIndex178) )
            & ( v6561_4__array(VarNext,A,bitIndex15)
            <=> v6953(VarNext,bitIndex177) )
            & ( v6561_4__array(VarNext,A,bitIndex14)
            <=> v6953(VarNext,bitIndex176) )
            & ( v6561_4__array(VarNext,A,bitIndex13)
            <=> v6953(VarNext,bitIndex175) )
            & ( v6561_4__array(VarNext,A,bitIndex12)
            <=> v6953(VarNext,bitIndex174) )
            & ( v6561_4__array(VarNext,A,bitIndex11)
            <=> v6953(VarNext,bitIndex173) )
            & ( v6561_4__array(VarNext,A,bitIndex10)
            <=> v6953(VarNext,bitIndex172) )
            & ( v6561_4__array(VarNext,A,bitIndex9)
            <=> v6953(VarNext,bitIndex171) )
            & ( v6561_4__array(VarNext,A,bitIndex8)
            <=> v6953(VarNext,bitIndex170) )
            & ( v6561_4__array(VarNext,A,bitIndex7)
            <=> v6953(VarNext,bitIndex169) )
            & ( v6561_4__array(VarNext,A,bitIndex6)
            <=> v6953(VarNext,bitIndex168) )
            & ( v6561_4__array(VarNext,A,bitIndex5)
            <=> v6953(VarNext,bitIndex167) )
            & ( v6561_4__array(VarNext,A,bitIndex4)
            <=> v6953(VarNext,bitIndex166) )
            & ( v6561_4__array(VarNext,A,bitIndex3)
            <=> v6953(VarNext,bitIndex165) )
            & ( v6561_4__array(VarNext,A,bitIndex2)
            <=> v6953(VarNext,bitIndex164) )
            & ( v6561_4__array(VarNext,A,bitIndex1)
            <=> v6953(VarNext,bitIndex163) )
            & ( v6561_4__array(VarNext,A,bitIndex0)
            <=> v6953(VarNext,bitIndex162) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1261,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6947(VarNext)
      <=> ( v6948(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1260,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6948(VarNext)
      <=> ( v6950(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_593,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6950(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_5,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b0010_address_term = A
              & v6938(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_3__array(VarNext,A,B)
              <=> v6561_2__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_5,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b0010_address_term = A
            & v6938(VarNext) )
         => ( ( v6561_3__array(VarNext,A,bitIndex53)
            <=> v6944(VarNext,bitIndex161) )
            & ( v6561_3__array(VarNext,A,bitIndex52)
            <=> v6944(VarNext,bitIndex160) )
            & ( v6561_3__array(VarNext,A,bitIndex51)
            <=> v6944(VarNext,bitIndex159) )
            & ( v6561_3__array(VarNext,A,bitIndex50)
            <=> v6944(VarNext,bitIndex158) )
            & ( v6561_3__array(VarNext,A,bitIndex49)
            <=> v6944(VarNext,bitIndex157) )
            & ( v6561_3__array(VarNext,A,bitIndex48)
            <=> v6944(VarNext,bitIndex156) )
            & ( v6561_3__array(VarNext,A,bitIndex47)
            <=> v6944(VarNext,bitIndex155) )
            & ( v6561_3__array(VarNext,A,bitIndex46)
            <=> v6944(VarNext,bitIndex154) )
            & ( v6561_3__array(VarNext,A,bitIndex45)
            <=> v6944(VarNext,bitIndex153) )
            & ( v6561_3__array(VarNext,A,bitIndex44)
            <=> v6944(VarNext,bitIndex152) )
            & ( v6561_3__array(VarNext,A,bitIndex43)
            <=> v6944(VarNext,bitIndex151) )
            & ( v6561_3__array(VarNext,A,bitIndex42)
            <=> v6944(VarNext,bitIndex150) )
            & ( v6561_3__array(VarNext,A,bitIndex41)
            <=> v6944(VarNext,bitIndex149) )
            & ( v6561_3__array(VarNext,A,bitIndex40)
            <=> v6944(VarNext,bitIndex148) )
            & ( v6561_3__array(VarNext,A,bitIndex39)
            <=> v6944(VarNext,bitIndex147) )
            & ( v6561_3__array(VarNext,A,bitIndex38)
            <=> v6944(VarNext,bitIndex146) )
            & ( v6561_3__array(VarNext,A,bitIndex37)
            <=> v6944(VarNext,bitIndex145) )
            & ( v6561_3__array(VarNext,A,bitIndex36)
            <=> v6944(VarNext,bitIndex144) )
            & ( v6561_3__array(VarNext,A,bitIndex35)
            <=> v6944(VarNext,bitIndex143) )
            & ( v6561_3__array(VarNext,A,bitIndex34)
            <=> v6944(VarNext,bitIndex142) )
            & ( v6561_3__array(VarNext,A,bitIndex33)
            <=> v6944(VarNext,bitIndex141) )
            & ( v6561_3__array(VarNext,A,bitIndex32)
            <=> v6944(VarNext,bitIndex140) )
            & ( v6561_3__array(VarNext,A,bitIndex31)
            <=> v6944(VarNext,bitIndex139) )
            & ( v6561_3__array(VarNext,A,bitIndex30)
            <=> v6944(VarNext,bitIndex138) )
            & ( v6561_3__array(VarNext,A,bitIndex29)
            <=> v6944(VarNext,bitIndex137) )
            & ( v6561_3__array(VarNext,A,bitIndex28)
            <=> v6944(VarNext,bitIndex136) )
            & ( v6561_3__array(VarNext,A,bitIndex27)
            <=> v6944(VarNext,bitIndex135) )
            & ( v6561_3__array(VarNext,A,bitIndex26)
            <=> v6944(VarNext,bitIndex134) )
            & ( v6561_3__array(VarNext,A,bitIndex25)
            <=> v6944(VarNext,bitIndex133) )
            & ( v6561_3__array(VarNext,A,bitIndex24)
            <=> v6944(VarNext,bitIndex132) )
            & ( v6561_3__array(VarNext,A,bitIndex23)
            <=> v6944(VarNext,bitIndex131) )
            & ( v6561_3__array(VarNext,A,bitIndex22)
            <=> v6944(VarNext,bitIndex130) )
            & ( v6561_3__array(VarNext,A,bitIndex21)
            <=> v6944(VarNext,bitIndex129) )
            & ( v6561_3__array(VarNext,A,bitIndex20)
            <=> v6944(VarNext,bitIndex128) )
            & ( v6561_3__array(VarNext,A,bitIndex19)
            <=> v6944(VarNext,bitIndex127) )
            & ( v6561_3__array(VarNext,A,bitIndex18)
            <=> v6944(VarNext,bitIndex126) )
            & ( v6561_3__array(VarNext,A,bitIndex17)
            <=> v6944(VarNext,bitIndex125) )
            & ( v6561_3__array(VarNext,A,bitIndex16)
            <=> v6944(VarNext,bitIndex124) )
            & ( v6561_3__array(VarNext,A,bitIndex15)
            <=> v6944(VarNext,bitIndex123) )
            & ( v6561_3__array(VarNext,A,bitIndex14)
            <=> v6944(VarNext,bitIndex122) )
            & ( v6561_3__array(VarNext,A,bitIndex13)
            <=> v6944(VarNext,bitIndex121) )
            & ( v6561_3__array(VarNext,A,bitIndex12)
            <=> v6944(VarNext,bitIndex120) )
            & ( v6561_3__array(VarNext,A,bitIndex11)
            <=> v6944(VarNext,bitIndex119) )
            & ( v6561_3__array(VarNext,A,bitIndex10)
            <=> v6944(VarNext,bitIndex118) )
            & ( v6561_3__array(VarNext,A,bitIndex9)
            <=> v6944(VarNext,bitIndex117) )
            & ( v6561_3__array(VarNext,A,bitIndex8)
            <=> v6944(VarNext,bitIndex116) )
            & ( v6561_3__array(VarNext,A,bitIndex7)
            <=> v6944(VarNext,bitIndex115) )
            & ( v6561_3__array(VarNext,A,bitIndex6)
            <=> v6944(VarNext,bitIndex114) )
            & ( v6561_3__array(VarNext,A,bitIndex5)
            <=> v6944(VarNext,bitIndex113) )
            & ( v6561_3__array(VarNext,A,bitIndex4)
            <=> v6944(VarNext,bitIndex112) )
            & ( v6561_3__array(VarNext,A,bitIndex3)
            <=> v6944(VarNext,bitIndex111) )
            & ( v6561_3__array(VarNext,A,bitIndex2)
            <=> v6944(VarNext,bitIndex110) )
            & ( v6561_3__array(VarNext,A,bitIndex1)
            <=> v6944(VarNext,bitIndex109) )
            & ( v6561_3__array(VarNext,A,bitIndex0)
            <=> v6944(VarNext,bitIndex108) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1259,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6938(VarNext)
      <=> ( v6939(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1258,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6939(VarNext)
      <=> ( v6941(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_592,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6941(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_4,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b0001_address_term = A
              & v6929(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_2__array(VarNext,A,B)
              <=> v6561_1__array(VarNext,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_4,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b0001_address_term = A
            & v6929(VarNext) )
         => ( ( v6561_2__array(VarNext,A,bitIndex53)
            <=> v6935(VarNext,bitIndex107) )
            & ( v6561_2__array(VarNext,A,bitIndex52)
            <=> v6935(VarNext,bitIndex106) )
            & ( v6561_2__array(VarNext,A,bitIndex51)
            <=> v6935(VarNext,bitIndex105) )
            & ( v6561_2__array(VarNext,A,bitIndex50)
            <=> v6935(VarNext,bitIndex104) )
            & ( v6561_2__array(VarNext,A,bitIndex49)
            <=> v6935(VarNext,bitIndex103) )
            & ( v6561_2__array(VarNext,A,bitIndex48)
            <=> v6935(VarNext,bitIndex102) )
            & ( v6561_2__array(VarNext,A,bitIndex47)
            <=> v6935(VarNext,bitIndex101) )
            & ( v6561_2__array(VarNext,A,bitIndex46)
            <=> v6935(VarNext,bitIndex100) )
            & ( v6561_2__array(VarNext,A,bitIndex45)
            <=> v6935(VarNext,bitIndex99) )
            & ( v6561_2__array(VarNext,A,bitIndex44)
            <=> v6935(VarNext,bitIndex98) )
            & ( v6561_2__array(VarNext,A,bitIndex43)
            <=> v6935(VarNext,bitIndex97) )
            & ( v6561_2__array(VarNext,A,bitIndex42)
            <=> v6935(VarNext,bitIndex96) )
            & ( v6561_2__array(VarNext,A,bitIndex41)
            <=> v6935(VarNext,bitIndex95) )
            & ( v6561_2__array(VarNext,A,bitIndex40)
            <=> v6935(VarNext,bitIndex94) )
            & ( v6561_2__array(VarNext,A,bitIndex39)
            <=> v6935(VarNext,bitIndex93) )
            & ( v6561_2__array(VarNext,A,bitIndex38)
            <=> v6935(VarNext,bitIndex92) )
            & ( v6561_2__array(VarNext,A,bitIndex37)
            <=> v6935(VarNext,bitIndex91) )
            & ( v6561_2__array(VarNext,A,bitIndex36)
            <=> v6935(VarNext,bitIndex90) )
            & ( v6561_2__array(VarNext,A,bitIndex35)
            <=> v6935(VarNext,bitIndex89) )
            & ( v6561_2__array(VarNext,A,bitIndex34)
            <=> v6935(VarNext,bitIndex88) )
            & ( v6561_2__array(VarNext,A,bitIndex33)
            <=> v6935(VarNext,bitIndex87) )
            & ( v6561_2__array(VarNext,A,bitIndex32)
            <=> v6935(VarNext,bitIndex86) )
            & ( v6561_2__array(VarNext,A,bitIndex31)
            <=> v6935(VarNext,bitIndex85) )
            & ( v6561_2__array(VarNext,A,bitIndex30)
            <=> v6935(VarNext,bitIndex84) )
            & ( v6561_2__array(VarNext,A,bitIndex29)
            <=> v6935(VarNext,bitIndex83) )
            & ( v6561_2__array(VarNext,A,bitIndex28)
            <=> v6935(VarNext,bitIndex82) )
            & ( v6561_2__array(VarNext,A,bitIndex27)
            <=> v6935(VarNext,bitIndex81) )
            & ( v6561_2__array(VarNext,A,bitIndex26)
            <=> v6935(VarNext,bitIndex80) )
            & ( v6561_2__array(VarNext,A,bitIndex25)
            <=> v6935(VarNext,bitIndex79) )
            & ( v6561_2__array(VarNext,A,bitIndex24)
            <=> v6935(VarNext,bitIndex78) )
            & ( v6561_2__array(VarNext,A,bitIndex23)
            <=> v6935(VarNext,bitIndex77) )
            & ( v6561_2__array(VarNext,A,bitIndex22)
            <=> v6935(VarNext,bitIndex76) )
            & ( v6561_2__array(VarNext,A,bitIndex21)
            <=> v6935(VarNext,bitIndex75) )
            & ( v6561_2__array(VarNext,A,bitIndex20)
            <=> v6935(VarNext,bitIndex74) )
            & ( v6561_2__array(VarNext,A,bitIndex19)
            <=> v6935(VarNext,bitIndex73) )
            & ( v6561_2__array(VarNext,A,bitIndex18)
            <=> v6935(VarNext,bitIndex72) )
            & ( v6561_2__array(VarNext,A,bitIndex17)
            <=> v6935(VarNext,bitIndex71) )
            & ( v6561_2__array(VarNext,A,bitIndex16)
            <=> v6935(VarNext,bitIndex70) )
            & ( v6561_2__array(VarNext,A,bitIndex15)
            <=> v6935(VarNext,bitIndex69) )
            & ( v6561_2__array(VarNext,A,bitIndex14)
            <=> v6935(VarNext,bitIndex68) )
            & ( v6561_2__array(VarNext,A,bitIndex13)
            <=> v6935(VarNext,bitIndex67) )
            & ( v6561_2__array(VarNext,A,bitIndex12)
            <=> v6935(VarNext,bitIndex66) )
            & ( v6561_2__array(VarNext,A,bitIndex11)
            <=> v6935(VarNext,bitIndex65) )
            & ( v6561_2__array(VarNext,A,bitIndex10)
            <=> v6935(VarNext,bitIndex64) )
            & ( v6561_2__array(VarNext,A,bitIndex9)
            <=> v6935(VarNext,bitIndex63) )
            & ( v6561_2__array(VarNext,A,bitIndex8)
            <=> v6935(VarNext,bitIndex62) )
            & ( v6561_2__array(VarNext,A,bitIndex7)
            <=> v6935(VarNext,bitIndex61) )
            & ( v6561_2__array(VarNext,A,bitIndex6)
            <=> v6935(VarNext,bitIndex60) )
            & ( v6561_2__array(VarNext,A,bitIndex5)
            <=> v6935(VarNext,bitIndex59) )
            & ( v6561_2__array(VarNext,A,bitIndex4)
            <=> v6935(VarNext,bitIndex58) )
            & ( v6561_2__array(VarNext,A,bitIndex3)
            <=> v6935(VarNext,bitIndex57) )
            & ( v6561_2__array(VarNext,A,bitIndex2)
            <=> v6935(VarNext,bitIndex56) )
            & ( v6561_2__array(VarNext,A,bitIndex1)
            <=> v6935(VarNext,bitIndex55) )
            & ( v6561_2__array(VarNext,A,bitIndex0)
            <=> v6935(VarNext,bitIndex54) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1257,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6929(VarNext)
      <=> ( v6930(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1256,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6930(VarNext)
      <=> ( v6932(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_591,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6932(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(memoryWriteDisabled_3,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( b0000_address_term = A
              & v6912(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_1__array(VarNext,A,B)
              <=> v6561_array(VarCurr,A,B) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_3,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( b0000_address_term = A
            & v6912(VarNext) )
         => ! [B] :
              ( range_53_0(B)
             => ( v6561_1__array(VarNext,A,B)
              <=> v6926(VarNext,B) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1255,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6912(VarNext)
      <=> ( v6913(VarNext)
          & v6921(VarNext) ) ) ) ).

fof(addAssignment_1755,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6921(VarNext)
      <=> v6919(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1254,axiom,
    ! [VarCurr] :
      ( v6919(VarCurr)
    <=> ( v6922(VarCurr)
        & v6924(VarCurr) ) ) ).

fof(writeUnaryOperator_590,axiom,
    ! [VarCurr] :
      ( ~ v6924(VarCurr)
    <=> v6883(VarCurr) ) ).

fof(writeUnaryOperator_589,axiom,
    ! [VarCurr] :
      ( ~ v6922(VarCurr)
    <=> v6923(VarCurr) ) ).

fof(writeUnaryOperator_588,axiom,
    ! [VarCurr] :
      ( ~ v6923(VarCurr)
    <=> v6566(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1253,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6913(VarNext)
      <=> ( v6914(VarNext)
          & v6563(VarNext) ) ) ) ).

fof(writeUnaryOperator_587,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6914(VarNext)
      <=> v6916(VarNext) ) ) ).

fof(addAssignment_1754,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6916(VarNext)
      <=> v6563(VarCurr) ) ) ).

fof(initSateConstraint_223,axiom,
    ~ v6561_array(constB0,b1111_address_term,bitIndex0) ).

fof(initSateConstraint_222,axiom,
    ~ v6561_array(constB0,b1111_address_term,bitIndex1) ).

fof(initSateConstraint_221,axiom,
    ~ v6561_array(constB0,b1111_address_term,bitIndex2) ).

fof(initSateConstraint_220,axiom,
    ~ v6561_array(constB0,b1111_address_term,bitIndex3) ).

fof(initSateConstraint_219,axiom,
    ~ v6561_array(constB0,b1111_address_term,bitIndex4) ).

fof(initSateConstraint_218,axiom,
    ~ v6561_array(constB0,b1111_address_term,bitIndex32) ).

fof(initSateConstraint_217,axiom,
    ~ v6561_array(constB0,b1111_address_term,bitIndex36) ).

fof(initSateConstraint_216,axiom,
    ~ v6561_array(constB0,b1111_address_term,bitIndex47) ).

fof(initSateConstraint_215,axiom,
    ~ v6561_array(constB0,b1111_address_term,bitIndex48) ).

fof(initSateConstraint_214,axiom,
    ~ v6561_array(constB0,b1111_address_term,bitIndex49) ).

fof(initSateConstraint_213,axiom,
    ~ v6561_array(constB0,b1111_address_term,bitIndex50) ).

fof(initSateConstraint_212,axiom,
    ~ v6561_array(constB0,b1111_address_term,bitIndex51) ).

fof(initSateConstraint_211,axiom,
    ~ v6561_array(constB0,b1111_address_term,bitIndex52) ).

fof(initSateConstraint_210,axiom,
    ~ v6561_array(constB0,b1111_address_term,bitIndex53) ).

fof(initSateConstraint_209,axiom,
    ~ v6561_array(constB0,b1110_address_term,bitIndex0) ).

fof(initSateConstraint_208,axiom,
    ~ v6561_array(constB0,b1110_address_term,bitIndex1) ).

fof(initSateConstraint_207,axiom,
    ~ v6561_array(constB0,b1110_address_term,bitIndex2) ).

fof(initSateConstraint_206,axiom,
    ~ v6561_array(constB0,b1110_address_term,bitIndex3) ).

fof(initSateConstraint_205,axiom,
    ~ v6561_array(constB0,b1110_address_term,bitIndex4) ).

fof(initSateConstraint_204,axiom,
    ~ v6561_array(constB0,b1110_address_term,bitIndex32) ).

fof(initSateConstraint_203,axiom,
    ~ v6561_array(constB0,b1110_address_term,bitIndex36) ).

fof(initSateConstraint_202,axiom,
    ~ v6561_array(constB0,b1110_address_term,bitIndex47) ).

fof(initSateConstraint_201,axiom,
    ~ v6561_array(constB0,b1110_address_term,bitIndex48) ).

fof(initSateConstraint_200,axiom,
    ~ v6561_array(constB0,b1110_address_term,bitIndex49) ).

fof(initSateConstraint_199,axiom,
    ~ v6561_array(constB0,b1110_address_term,bitIndex50) ).

fof(initSateConstraint_198,axiom,
    ~ v6561_array(constB0,b1110_address_term,bitIndex51) ).

fof(initSateConstraint_197,axiom,
    ~ v6561_array(constB0,b1110_address_term,bitIndex52) ).

fof(initSateConstraint_196,axiom,
    ~ v6561_array(constB0,b1110_address_term,bitIndex53) ).

fof(initSateConstraint_195,axiom,
    ~ v6561_array(constB0,b1101_address_term,bitIndex0) ).

fof(initSateConstraint_194,axiom,
    ~ v6561_array(constB0,b1101_address_term,bitIndex1) ).

fof(initSateConstraint_193,axiom,
    ~ v6561_array(constB0,b1101_address_term,bitIndex2) ).

fof(initSateConstraint_192,axiom,
    ~ v6561_array(constB0,b1101_address_term,bitIndex3) ).

fof(initSateConstraint_191,axiom,
    ~ v6561_array(constB0,b1101_address_term,bitIndex4) ).

fof(initSateConstraint_190,axiom,
    ~ v6561_array(constB0,b1101_address_term,bitIndex32) ).

fof(initSateConstraint_189,axiom,
    ~ v6561_array(constB0,b1101_address_term,bitIndex36) ).

fof(initSateConstraint_188,axiom,
    ~ v6561_array(constB0,b1101_address_term,bitIndex47) ).

fof(initSateConstraint_187,axiom,
    ~ v6561_array(constB0,b1101_address_term,bitIndex48) ).

fof(initSateConstraint_186,axiom,
    ~ v6561_array(constB0,b1101_address_term,bitIndex49) ).

fof(initSateConstraint_185,axiom,
    ~ v6561_array(constB0,b1101_address_term,bitIndex50) ).

fof(initSateConstraint_184,axiom,
    ~ v6561_array(constB0,b1101_address_term,bitIndex51) ).

fof(initSateConstraint_183,axiom,
    ~ v6561_array(constB0,b1101_address_term,bitIndex52) ).

fof(initSateConstraint_182,axiom,
    ~ v6561_array(constB0,b1101_address_term,bitIndex53) ).

fof(initSateConstraint_181,axiom,
    ~ v6561_array(constB0,b1100_address_term,bitIndex0) ).

fof(initSateConstraint_180,axiom,
    ~ v6561_array(constB0,b1100_address_term,bitIndex1) ).

fof(initSateConstraint_179,axiom,
    ~ v6561_array(constB0,b1100_address_term,bitIndex2) ).

fof(initSateConstraint_178,axiom,
    ~ v6561_array(constB0,b1100_address_term,bitIndex3) ).

fof(initSateConstraint_177,axiom,
    ~ v6561_array(constB0,b1100_address_term,bitIndex4) ).

fof(initSateConstraint_176,axiom,
    ~ v6561_array(constB0,b1100_address_term,bitIndex32) ).

fof(initSateConstraint_175,axiom,
    ~ v6561_array(constB0,b1100_address_term,bitIndex36) ).

fof(initSateConstraint_174,axiom,
    ~ v6561_array(constB0,b1100_address_term,bitIndex47) ).

fof(initSateConstraint_173,axiom,
    ~ v6561_array(constB0,b1100_address_term,bitIndex48) ).

fof(initSateConstraint_172,axiom,
    ~ v6561_array(constB0,b1100_address_term,bitIndex49) ).

fof(initSateConstraint_171,axiom,
    ~ v6561_array(constB0,b1100_address_term,bitIndex50) ).

fof(initSateConstraint_170,axiom,
    ~ v6561_array(constB0,b1100_address_term,bitIndex51) ).

fof(initSateConstraint_169,axiom,
    ~ v6561_array(constB0,b1100_address_term,bitIndex52) ).

fof(initSateConstraint_168,axiom,
    ~ v6561_array(constB0,b1100_address_term,bitIndex53) ).

fof(initSateConstraint_167,axiom,
    ~ v6561_array(constB0,b1011_address_term,bitIndex0) ).

fof(initSateConstraint_166,axiom,
    ~ v6561_array(constB0,b1011_address_term,bitIndex1) ).

fof(initSateConstraint_165,axiom,
    ~ v6561_array(constB0,b1011_address_term,bitIndex2) ).

fof(initSateConstraint_164,axiom,
    ~ v6561_array(constB0,b1011_address_term,bitIndex3) ).

fof(initSateConstraint_163,axiom,
    ~ v6561_array(constB0,b1011_address_term,bitIndex4) ).

fof(initSateConstraint_162,axiom,
    ~ v6561_array(constB0,b1011_address_term,bitIndex32) ).

fof(initSateConstraint_161,axiom,
    ~ v6561_array(constB0,b1011_address_term,bitIndex36) ).

fof(initSateConstraint_160,axiom,
    ~ v6561_array(constB0,b1011_address_term,bitIndex47) ).

fof(initSateConstraint_159,axiom,
    ~ v6561_array(constB0,b1011_address_term,bitIndex48) ).

fof(initSateConstraint_158,axiom,
    ~ v6561_array(constB0,b1011_address_term,bitIndex49) ).

fof(initSateConstraint_157,axiom,
    ~ v6561_array(constB0,b1011_address_term,bitIndex50) ).

fof(initSateConstraint_156,axiom,
    ~ v6561_array(constB0,b1011_address_term,bitIndex51) ).

fof(initSateConstraint_155,axiom,
    ~ v6561_array(constB0,b1011_address_term,bitIndex52) ).

fof(initSateConstraint_154,axiom,
    ~ v6561_array(constB0,b1011_address_term,bitIndex53) ).

fof(initSateConstraint_153,axiom,
    ~ v6561_array(constB0,b1010_address_term,bitIndex0) ).

fof(initSateConstraint_152,axiom,
    ~ v6561_array(constB0,b1010_address_term,bitIndex1) ).

fof(initSateConstraint_151,axiom,
    ~ v6561_array(constB0,b1010_address_term,bitIndex2) ).

fof(initSateConstraint_150,axiom,
    ~ v6561_array(constB0,b1010_address_term,bitIndex3) ).

fof(initSateConstraint_149,axiom,
    ~ v6561_array(constB0,b1010_address_term,bitIndex4) ).

fof(initSateConstraint_148,axiom,
    ~ v6561_array(constB0,b1010_address_term,bitIndex32) ).

fof(initSateConstraint_147,axiom,
    ~ v6561_array(constB0,b1010_address_term,bitIndex36) ).

fof(initSateConstraint_146,axiom,
    ~ v6561_array(constB0,b1010_address_term,bitIndex47) ).

fof(initSateConstraint_145,axiom,
    ~ v6561_array(constB0,b1010_address_term,bitIndex48) ).

fof(initSateConstraint_144,axiom,
    ~ v6561_array(constB0,b1010_address_term,bitIndex49) ).

fof(initSateConstraint_143,axiom,
    ~ v6561_array(constB0,b1010_address_term,bitIndex50) ).

fof(initSateConstraint_142,axiom,
    ~ v6561_array(constB0,b1010_address_term,bitIndex51) ).

fof(initSateConstraint_141,axiom,
    ~ v6561_array(constB0,b1010_address_term,bitIndex52) ).

fof(initSateConstraint_140,axiom,
    ~ v6561_array(constB0,b1010_address_term,bitIndex53) ).

fof(initSateConstraint_139,axiom,
    ~ v6561_array(constB0,b1001_address_term,bitIndex0) ).

fof(initSateConstraint_138,axiom,
    ~ v6561_array(constB0,b1001_address_term,bitIndex1) ).

fof(initSateConstraint_137,axiom,
    ~ v6561_array(constB0,b1001_address_term,bitIndex2) ).

fof(initSateConstraint_136,axiom,
    ~ v6561_array(constB0,b1001_address_term,bitIndex3) ).

fof(initSateConstraint_135,axiom,
    ~ v6561_array(constB0,b1001_address_term,bitIndex4) ).

fof(initSateConstraint_134,axiom,
    ~ v6561_array(constB0,b1001_address_term,bitIndex32) ).

fof(initSateConstraint_133,axiom,
    ~ v6561_array(constB0,b1001_address_term,bitIndex36) ).

fof(initSateConstraint_132,axiom,
    ~ v6561_array(constB0,b1001_address_term,bitIndex47) ).

fof(initSateConstraint_131,axiom,
    ~ v6561_array(constB0,b1001_address_term,bitIndex48) ).

fof(initSateConstraint_130,axiom,
    ~ v6561_array(constB0,b1001_address_term,bitIndex49) ).

fof(initSateConstraint_129,axiom,
    ~ v6561_array(constB0,b1001_address_term,bitIndex50) ).

fof(initSateConstraint_128,axiom,
    ~ v6561_array(constB0,b1001_address_term,bitIndex51) ).

fof(initSateConstraint_127,axiom,
    ~ v6561_array(constB0,b1001_address_term,bitIndex52) ).

fof(initSateConstraint_126,axiom,
    ~ v6561_array(constB0,b1001_address_term,bitIndex53) ).

fof(initSateConstraint_125,axiom,
    ~ v6561_array(constB0,b1000_address_term,bitIndex0) ).

fof(initSateConstraint_124,axiom,
    ~ v6561_array(constB0,b1000_address_term,bitIndex1) ).

fof(initSateConstraint_123,axiom,
    ~ v6561_array(constB0,b1000_address_term,bitIndex2) ).

fof(initSateConstraint_122,axiom,
    ~ v6561_array(constB0,b1000_address_term,bitIndex3) ).

fof(initSateConstraint_121,axiom,
    ~ v6561_array(constB0,b1000_address_term,bitIndex4) ).

fof(initSateConstraint_120,axiom,
    ~ v6561_array(constB0,b1000_address_term,bitIndex32) ).

fof(initSateConstraint_119,axiom,
    ~ v6561_array(constB0,b1000_address_term,bitIndex36) ).

fof(initSateConstraint_118,axiom,
    ~ v6561_array(constB0,b1000_address_term,bitIndex47) ).

fof(initSateConstraint_117,axiom,
    ~ v6561_array(constB0,b1000_address_term,bitIndex48) ).

fof(initSateConstraint_116,axiom,
    ~ v6561_array(constB0,b1000_address_term,bitIndex49) ).

fof(initSateConstraint_115,axiom,
    ~ v6561_array(constB0,b1000_address_term,bitIndex50) ).

fof(initSateConstraint_114,axiom,
    ~ v6561_array(constB0,b1000_address_term,bitIndex51) ).

fof(initSateConstraint_113,axiom,
    ~ v6561_array(constB0,b1000_address_term,bitIndex52) ).

fof(initSateConstraint_112,axiom,
    ~ v6561_array(constB0,b1000_address_term,bitIndex53) ).

fof(initSateConstraint_111,axiom,
    ~ v6561_array(constB0,b0111_address_term,bitIndex0) ).

fof(initSateConstraint_110,axiom,
    ~ v6561_array(constB0,b0111_address_term,bitIndex1) ).

fof(initSateConstraint_109,axiom,
    ~ v6561_array(constB0,b0111_address_term,bitIndex2) ).

fof(initSateConstraint_108,axiom,
    ~ v6561_array(constB0,b0111_address_term,bitIndex3) ).

fof(initSateConstraint_107,axiom,
    ~ v6561_array(constB0,b0111_address_term,bitIndex4) ).

fof(initSateConstraint_106,axiom,
    ~ v6561_array(constB0,b0111_address_term,bitIndex32) ).

fof(initSateConstraint_105,axiom,
    ~ v6561_array(constB0,b0111_address_term,bitIndex36) ).

fof(initSateConstraint_104,axiom,
    ~ v6561_array(constB0,b0111_address_term,bitIndex47) ).

fof(initSateConstraint_103,axiom,
    ~ v6561_array(constB0,b0111_address_term,bitIndex48) ).

fof(initSateConstraint_102,axiom,
    ~ v6561_array(constB0,b0111_address_term,bitIndex49) ).

fof(initSateConstraint_101,axiom,
    ~ v6561_array(constB0,b0111_address_term,bitIndex50) ).

fof(initSateConstraint_100,axiom,
    ~ v6561_array(constB0,b0111_address_term,bitIndex51) ).

fof(initSateConstraint_99,axiom,
    ~ v6561_array(constB0,b0111_address_term,bitIndex52) ).

fof(initSateConstraint_98,axiom,
    ~ v6561_array(constB0,b0111_address_term,bitIndex53) ).

fof(initSateConstraint_97,axiom,
    ~ v6561_array(constB0,b0110_address_term,bitIndex0) ).

fof(initSateConstraint_96,axiom,
    ~ v6561_array(constB0,b0110_address_term,bitIndex1) ).

fof(initSateConstraint_95,axiom,
    ~ v6561_array(constB0,b0110_address_term,bitIndex2) ).

fof(initSateConstraint_94,axiom,
    ~ v6561_array(constB0,b0110_address_term,bitIndex3) ).

fof(initSateConstraint_93,axiom,
    ~ v6561_array(constB0,b0110_address_term,bitIndex4) ).

fof(initSateConstraint_92,axiom,
    ~ v6561_array(constB0,b0110_address_term,bitIndex32) ).

fof(initSateConstraint_91,axiom,
    ~ v6561_array(constB0,b0110_address_term,bitIndex36) ).

fof(initSateConstraint_90,axiom,
    ~ v6561_array(constB0,b0110_address_term,bitIndex47) ).

fof(initSateConstraint_89,axiom,
    ~ v6561_array(constB0,b0110_address_term,bitIndex48) ).

fof(initSateConstraint_88,axiom,
    ~ v6561_array(constB0,b0110_address_term,bitIndex49) ).

fof(initSateConstraint_87,axiom,
    ~ v6561_array(constB0,b0110_address_term,bitIndex50) ).

fof(initSateConstraint_86,axiom,
    ~ v6561_array(constB0,b0110_address_term,bitIndex51) ).

fof(initSateConstraint_85,axiom,
    ~ v6561_array(constB0,b0110_address_term,bitIndex52) ).

fof(initSateConstraint_84,axiom,
    ~ v6561_array(constB0,b0110_address_term,bitIndex53) ).

fof(initSateConstraint_83,axiom,
    ~ v6561_array(constB0,b0101_address_term,bitIndex0) ).

fof(initSateConstraint_82,axiom,
    ~ v6561_array(constB0,b0101_address_term,bitIndex1) ).

fof(initSateConstraint_81,axiom,
    ~ v6561_array(constB0,b0101_address_term,bitIndex2) ).

fof(initSateConstraint_80,axiom,
    ~ v6561_array(constB0,b0101_address_term,bitIndex3) ).

fof(initSateConstraint_79,axiom,
    ~ v6561_array(constB0,b0101_address_term,bitIndex4) ).

fof(initSateConstraint_78,axiom,
    ~ v6561_array(constB0,b0101_address_term,bitIndex32) ).

fof(initSateConstraint_77,axiom,
    ~ v6561_array(constB0,b0101_address_term,bitIndex36) ).

fof(initSateConstraint_76,axiom,
    ~ v6561_array(constB0,b0101_address_term,bitIndex47) ).

fof(initSateConstraint_75,axiom,
    ~ v6561_array(constB0,b0101_address_term,bitIndex48) ).

fof(initSateConstraint_74,axiom,
    ~ v6561_array(constB0,b0101_address_term,bitIndex49) ).

fof(initSateConstraint_73,axiom,
    ~ v6561_array(constB0,b0101_address_term,bitIndex50) ).

fof(initSateConstraint_72,axiom,
    ~ v6561_array(constB0,b0101_address_term,bitIndex51) ).

fof(initSateConstraint_71,axiom,
    ~ v6561_array(constB0,b0101_address_term,bitIndex52) ).

fof(initSateConstraint_70,axiom,
    ~ v6561_array(constB0,b0101_address_term,bitIndex53) ).

fof(initSateConstraint_69,axiom,
    ~ v6561_array(constB0,b0100_address_term,bitIndex0) ).

fof(initSateConstraint_68,axiom,
    ~ v6561_array(constB0,b0100_address_term,bitIndex1) ).

fof(initSateConstraint_67,axiom,
    ~ v6561_array(constB0,b0100_address_term,bitIndex2) ).

fof(initSateConstraint_66,axiom,
    ~ v6561_array(constB0,b0100_address_term,bitIndex3) ).

fof(initSateConstraint_65,axiom,
    ~ v6561_array(constB0,b0100_address_term,bitIndex4) ).

fof(initSateConstraint_64,axiom,
    ~ v6561_array(constB0,b0100_address_term,bitIndex32) ).

fof(initSateConstraint_63,axiom,
    ~ v6561_array(constB0,b0100_address_term,bitIndex36) ).

fof(initSateConstraint_62,axiom,
    ~ v6561_array(constB0,b0100_address_term,bitIndex47) ).

fof(initSateConstraint_61,axiom,
    ~ v6561_array(constB0,b0100_address_term,bitIndex48) ).

fof(initSateConstraint_60,axiom,
    ~ v6561_array(constB0,b0100_address_term,bitIndex49) ).

fof(initSateConstraint_59,axiom,
    ~ v6561_array(constB0,b0100_address_term,bitIndex50) ).

fof(initSateConstraint_58,axiom,
    ~ v6561_array(constB0,b0100_address_term,bitIndex51) ).

fof(initSateConstraint_57,axiom,
    ~ v6561_array(constB0,b0100_address_term,bitIndex52) ).

fof(initSateConstraint_56,axiom,
    ~ v6561_array(constB0,b0100_address_term,bitIndex53) ).

fof(initSateConstraint_55,axiom,
    ~ v6561_array(constB0,b0011_address_term,bitIndex0) ).

fof(initSateConstraint_54,axiom,
    ~ v6561_array(constB0,b0011_address_term,bitIndex1) ).

fof(initSateConstraint_53,axiom,
    ~ v6561_array(constB0,b0011_address_term,bitIndex2) ).

fof(initSateConstraint_52,axiom,
    ~ v6561_array(constB0,b0011_address_term,bitIndex3) ).

fof(initSateConstraint_51,axiom,
    ~ v6561_array(constB0,b0011_address_term,bitIndex4) ).

fof(initSateConstraint_50,axiom,
    ~ v6561_array(constB0,b0011_address_term,bitIndex32) ).

fof(initSateConstraint_49,axiom,
    ~ v6561_array(constB0,b0011_address_term,bitIndex36) ).

fof(initSateConstraint_48,axiom,
    ~ v6561_array(constB0,b0011_address_term,bitIndex47) ).

fof(initSateConstraint_47,axiom,
    ~ v6561_array(constB0,b0011_address_term,bitIndex48) ).

fof(initSateConstraint_46,axiom,
    ~ v6561_array(constB0,b0011_address_term,bitIndex49) ).

fof(initSateConstraint_45,axiom,
    ~ v6561_array(constB0,b0011_address_term,bitIndex50) ).

fof(initSateConstraint_44,axiom,
    ~ v6561_array(constB0,b0011_address_term,bitIndex51) ).

fof(initSateConstraint_43,axiom,
    ~ v6561_array(constB0,b0011_address_term,bitIndex52) ).

fof(initSateConstraint_42,axiom,
    ~ v6561_array(constB0,b0011_address_term,bitIndex53) ).

fof(initSateConstraint_41,axiom,
    ~ v6561_array(constB0,b0010_address_term,bitIndex0) ).

fof(initSateConstraint_40,axiom,
    ~ v6561_array(constB0,b0010_address_term,bitIndex1) ).

fof(initSateConstraint_39,axiom,
    ~ v6561_array(constB0,b0010_address_term,bitIndex2) ).

fof(initSateConstraint_38,axiom,
    ~ v6561_array(constB0,b0010_address_term,bitIndex3) ).

fof(initSateConstraint_37,axiom,
    ~ v6561_array(constB0,b0010_address_term,bitIndex4) ).

fof(initSateConstraint_36,axiom,
    ~ v6561_array(constB0,b0010_address_term,bitIndex32) ).

fof(initSateConstraint_35,axiom,
    ~ v6561_array(constB0,b0010_address_term,bitIndex36) ).

fof(initSateConstraint_34,axiom,
    ~ v6561_array(constB0,b0010_address_term,bitIndex47) ).

fof(initSateConstraint_33,axiom,
    ~ v6561_array(constB0,b0010_address_term,bitIndex48) ).

fof(initSateConstraint_32,axiom,
    ~ v6561_array(constB0,b0010_address_term,bitIndex49) ).

fof(initSateConstraint_31,axiom,
    ~ v6561_array(constB0,b0010_address_term,bitIndex50) ).

fof(initSateConstraint_30,axiom,
    ~ v6561_array(constB0,b0010_address_term,bitIndex51) ).

fof(initSateConstraint_29,axiom,
    ~ v6561_array(constB0,b0010_address_term,bitIndex52) ).

fof(initSateConstraint_28,axiom,
    ~ v6561_array(constB0,b0010_address_term,bitIndex53) ).

fof(initSateConstraint_27,axiom,
    ~ v6561_array(constB0,b0001_address_term,bitIndex0) ).

fof(initSateConstraint_26,axiom,
    ~ v6561_array(constB0,b0001_address_term,bitIndex1) ).

fof(initSateConstraint_25,axiom,
    ~ v6561_array(constB0,b0001_address_term,bitIndex2) ).

fof(initSateConstraint_24,axiom,
    ~ v6561_array(constB0,b0001_address_term,bitIndex3) ).

fof(initSateConstraint_23,axiom,
    ~ v6561_array(constB0,b0001_address_term,bitIndex4) ).

fof(initSateConstraint_22,axiom,
    ~ v6561_array(constB0,b0001_address_term,bitIndex32) ).

fof(initSateConstraint_21,axiom,
    ~ v6561_array(constB0,b0001_address_term,bitIndex36) ).

fof(initSateConstraint_20,axiom,
    ~ v6561_array(constB0,b0001_address_term,bitIndex47) ).

fof(initSateConstraint_19,axiom,
    ~ v6561_array(constB0,b0001_address_term,bitIndex48) ).

fof(initSateConstraint_18,axiom,
    ~ v6561_array(constB0,b0001_address_term,bitIndex49) ).

fof(initSateConstraint_17,axiom,
    ~ v6561_array(constB0,b0001_address_term,bitIndex50) ).

fof(initSateConstraint_16,axiom,
    ~ v6561_array(constB0,b0001_address_term,bitIndex51) ).

fof(initSateConstraint_15,axiom,
    ~ v6561_array(constB0,b0001_address_term,bitIndex52) ).

fof(initSateConstraint_14,axiom,
    ~ v6561_array(constB0,b0001_address_term,bitIndex53) ).

fof(initSateConstraint_13,axiom,
    ~ v6561_array(constB0,b0000_address_term,bitIndex0) ).

fof(initSateConstraint_12,axiom,
    ~ v6561_array(constB0,b0000_address_term,bitIndex1) ).

fof(initSateConstraint_11,axiom,
    ~ v6561_array(constB0,b0000_address_term,bitIndex2) ).

fof(initSateConstraint_10,axiom,
    ~ v6561_array(constB0,b0000_address_term,bitIndex3) ).

fof(initSateConstraint_9,axiom,
    ~ v6561_array(constB0,b0000_address_term,bitIndex4) ).

fof(initSateConstraint_8,axiom,
    ~ v6561_array(constB0,b0000_address_term,bitIndex32) ).

fof(initSateConstraint_7,axiom,
    ~ v6561_array(constB0,b0000_address_term,bitIndex36) ).

fof(initSateConstraint_6,axiom,
    ~ v6561_array(constB0,b0000_address_term,bitIndex47) ).

fof(initSateConstraint_5,axiom,
    ~ v6561_array(constB0,b0000_address_term,bitIndex48) ).

fof(initSateConstraint_4,axiom,
    ~ v6561_array(constB0,b0000_address_term,bitIndex49) ).

fof(initSateConstraint_3,axiom,
    ~ v6561_array(constB0,b0000_address_term,bitIndex50) ).

fof(initSateConstraint_2,axiom,
    ~ v6561_array(constB0,b0000_address_term,bitIndex51) ).

fof(initSateConstraint_1,axiom,
    ~ v6561_array(constB0,b0000_address_term,bitIndex52) ).

fof(initSateConstraint,axiom,
    ~ v6561_array(constB0,b0000_address_term,bitIndex53) ).

fof(addAssignment_1753,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v6904(VarCurr,B)
      <=> v6906(VarCurr,B) ) ) ).

fof(addAssignment_1752,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v6906(VarCurr,B)
      <=> v6908(VarCurr,B) ) ) ).

fof(addAssignment_1751,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v6908(VarCurr,B)
      <=> v5617(VarCurr,B) ) ) ).

fof(addAssignmentInitValueVector_32,axiom,
    ! [B] :
      ( range_3_0(B)
     => ( v5617(constB0,B)
      <=> $false ) ) ).

fof(addAssignment_1750,axiom,
    ! [VarCurr] :
      ( v6883(VarCurr)
    <=> v6885(VarCurr) ) ).

fof(addAssignment_1749,axiom,
    ! [VarCurr] :
      ( v6885(VarCurr)
    <=> v6887(VarCurr) ) ).

fof(addAssignment_1748,axiom,
    ! [VarCurr] :
      ( v6887(VarCurr)
    <=> v6889(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_121,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6892(VarNext)
       => ( v6889(VarNext)
        <=> v6889(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_130,axiom,
    ! [VarNext] :
      ( v6892(VarNext)
     => ( v6889(VarNext)
      <=> v6900(VarNext) ) ) ).

fof(addAssignment_1747,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6900(VarNext)
      <=> v6898(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_178,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ( v6898(VarCurr)
      <=> v6859(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_180,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ( v6898(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1252,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6892(VarNext)
      <=> v6893(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1251,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6893(VarNext)
      <=> ( v6895(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_586,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6895(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValueVector_31,axiom,
    ( v6889(constB0)
  <=> $false ) ).

fof(addAssignment_1746,axiom,
    ! [VarCurr,B] :
      ( range_53_0(B)
     => ( v6568(VarCurr,B)
      <=> v6570(VarCurr,B) ) ) ).

fof(addAssignment_1745,axiom,
    ! [VarCurr,B] :
      ( range_53_0(B)
     => ( v6570(VarCurr,B)
      <=> v6572(VarCurr,B) ) ) ).

fof(addAssignment_1744,axiom,
    ! [VarCurr,B] :
      ( range_53_0(B)
     => ( v6572(VarCurr,B)
      <=> v6574(VarCurr,B) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_120,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6866(VarNext)
       => ! [B] :
            ( range_53_0(B)
           => ( v6574(VarNext,B)
            <=> v6574(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_129,axiom,
    ! [VarNext] :
      ( v6866(VarNext)
     => ! [B] :
          ( range_53_0(B)
         => ( v6574(VarNext,B)
          <=> v6877(VarNext,B) ) ) ) ).

fof(addAssignment_1743,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_53_0(B)
         => ( v6877(VarNext,B)
          <=> v6875(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_177,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ! [B] :
          ( range_53_0(B)
         => ( v6875(VarCurr,B)
          <=> v6878(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_179,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ! [B] :
          ( range_53_0(B)
         => ( v6875(VarCurr,B)
          <=> $false ) ) ) ).

fof(range_axiom_46,axiom,
    ! [B] :
      ( range_53_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B
        | bitIndex11 = B
        | bitIndex12 = B
        | bitIndex13 = B
        | bitIndex14 = B
        | bitIndex15 = B
        | bitIndex16 = B
        | bitIndex17 = B
        | bitIndex18 = B
        | bitIndex19 = B
        | bitIndex20 = B
        | bitIndex21 = B
        | bitIndex22 = B
        | bitIndex23 = B
        | bitIndex24 = B
        | bitIndex25 = B
        | bitIndex26 = B
        | bitIndex27 = B
        | bitIndex28 = B
        | bitIndex29 = B
        | bitIndex30 = B
        | bitIndex31 = B
        | bitIndex32 = B
        | bitIndex33 = B
        | bitIndex34 = B
        | bitIndex35 = B
        | bitIndex36 = B
        | bitIndex37 = B
        | bitIndex38 = B
        | bitIndex39 = B
        | bitIndex40 = B
        | bitIndex41 = B
        | bitIndex42 = B
        | bitIndex43 = B
        | bitIndex44 = B
        | bitIndex45 = B
        | bitIndex46 = B
        | bitIndex47 = B
        | bitIndex48 = B
        | bitIndex49 = B
        | bitIndex50 = B
        | bitIndex51 = B
        | bitIndex52 = B
        | bitIndex53 = B ) ) ).

fof(bitBlastConstant_610,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex53) ).

fof(bitBlastConstant_609,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex52) ).

fof(bitBlastConstant_608,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex51) ).

fof(bitBlastConstant_607,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex50) ).

fof(bitBlastConstant_606,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex49) ).

fof(bitBlastConstant_605,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex48) ).

fof(bitBlastConstant_604,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex47) ).

fof(bitBlastConstant_603,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex46) ).

fof(bitBlastConstant_602,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex45) ).

fof(bitBlastConstant_601,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex44) ).

fof(bitBlastConstant_600,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex43) ).

fof(bitBlastConstant_599,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex42) ).

fof(bitBlastConstant_598,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex41) ).

fof(bitBlastConstant_597,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex40) ).

fof(bitBlastConstant_596,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex39) ).

fof(bitBlastConstant_595,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex38) ).

fof(bitBlastConstant_594,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex37) ).

fof(bitBlastConstant_593,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex36) ).

fof(bitBlastConstant_592,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex35) ).

fof(bitBlastConstant_591,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex34) ).

fof(bitBlastConstant_590,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex33) ).

fof(bitBlastConstant_589,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex32) ).

fof(bitBlastConstant_588,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex31) ).

fof(bitBlastConstant_587,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex30) ).

fof(bitBlastConstant_586,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex29) ).

fof(bitBlastConstant_585,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex28) ).

fof(bitBlastConstant_584,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex27) ).

fof(bitBlastConstant_583,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex26) ).

fof(bitBlastConstant_582,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex25) ).

fof(bitBlastConstant_581,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex24) ).

fof(bitBlastConstant_580,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex23) ).

fof(bitBlastConstant_579,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex22) ).

fof(bitBlastConstant_578,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex21) ).

fof(bitBlastConstant_577,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex20) ).

fof(bitBlastConstant_576,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex19) ).

fof(bitBlastConstant_575,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex18) ).

fof(bitBlastConstant_574,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex17) ).

fof(bitBlastConstant_573,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex16) ).

fof(bitBlastConstant_572,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex15) ).

fof(bitBlastConstant_571,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex14) ).

fof(bitBlastConstant_570,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex13) ).

fof(bitBlastConstant_569,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex12) ).

fof(bitBlastConstant_568,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex11) ).

fof(bitBlastConstant_567,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex10) ).

fof(bitBlastConstant_566,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex9) ).

fof(bitBlastConstant_565,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex8) ).

fof(bitBlastConstant_564,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex7) ).

fof(bitBlastConstant_563,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex6) ).

fof(bitBlastConstant_562,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex5) ).

fof(bitBlastConstant_561,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex4) ).

fof(bitBlastConstant_560,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex3) ).

fof(bitBlastConstant_559,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex2) ).

fof(bitBlastConstant_558,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex1) ).

fof(bitBlastConstant_557,axiom,
    ~ b000000000000000000000000000000000000000000000000000000(bitIndex0) ).

fof(addAssignment_1742,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6878(VarCurr,B)
      <=> v4699(VarCurr,B) ) ) ).

fof(addAssignment_1741,axiom,
    ! [VarCurr] :
      ( ( v6878(VarCurr,bitIndex10)
      <=> v6828(VarCurr,bitIndex5) )
      & ( v6878(VarCurr,bitIndex9)
      <=> v6828(VarCurr,bitIndex4) )
      & ( v6878(VarCurr,bitIndex8)
      <=> v6828(VarCurr,bitIndex3) )
      & ( v6878(VarCurr,bitIndex7)
      <=> v6828(VarCurr,bitIndex2) )
      & ( v6878(VarCurr,bitIndex6)
      <=> v6828(VarCurr,bitIndex1) )
      & ( v6878(VarCurr,bitIndex5)
      <=> v6828(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1740,axiom,
    ! [VarCurr] :
      ( ( v6878(VarCurr,bitIndex15)
      <=> v6798(VarCurr,bitIndex4) )
      & ( v6878(VarCurr,bitIndex14)
      <=> v6798(VarCurr,bitIndex3) )
      & ( v6878(VarCurr,bitIndex13)
      <=> v6798(VarCurr,bitIndex2) )
      & ( v6878(VarCurr,bitIndex12)
      <=> v6798(VarCurr,bitIndex1) )
      & ( v6878(VarCurr,bitIndex11)
      <=> v6798(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1739,axiom,
    ! [VarCurr] :
      ( ( v6878(VarCurr,bitIndex27)
      <=> v6767(VarCurr,bitIndex11) )
      & ( v6878(VarCurr,bitIndex26)
      <=> v6767(VarCurr,bitIndex10) )
      & ( v6878(VarCurr,bitIndex25)
      <=> v6767(VarCurr,bitIndex9) )
      & ( v6878(VarCurr,bitIndex24)
      <=> v6767(VarCurr,bitIndex8) )
      & ( v6878(VarCurr,bitIndex23)
      <=> v6767(VarCurr,bitIndex7) )
      & ( v6878(VarCurr,bitIndex22)
      <=> v6767(VarCurr,bitIndex6) )
      & ( v6878(VarCurr,bitIndex21)
      <=> v6767(VarCurr,bitIndex5) )
      & ( v6878(VarCurr,bitIndex20)
      <=> v6767(VarCurr,bitIndex4) )
      & ( v6878(VarCurr,bitIndex19)
      <=> v6767(VarCurr,bitIndex3) )
      & ( v6878(VarCurr,bitIndex18)
      <=> v6767(VarCurr,bitIndex2) )
      & ( v6878(VarCurr,bitIndex17)
      <=> v6767(VarCurr,bitIndex1) )
      & ( v6878(VarCurr,bitIndex16)
      <=> v6767(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1738,axiom,
    ! [VarCurr] :
      ( ( v6878(VarCurr,bitIndex35)
      <=> v6879(VarCurr,bitIndex7) )
      & ( v6878(VarCurr,bitIndex34)
      <=> v6879(VarCurr,bitIndex6) )
      & ( v6878(VarCurr,bitIndex33)
      <=> v6879(VarCurr,bitIndex5) )
      & ( v6878(VarCurr,bitIndex32)
      <=> v6879(VarCurr,bitIndex4) )
      & ( v6878(VarCurr,bitIndex31)
      <=> v6879(VarCurr,bitIndex3) )
      & ( v6878(VarCurr,bitIndex30)
      <=> v6879(VarCurr,bitIndex2) )
      & ( v6878(VarCurr,bitIndex29)
      <=> v6879(VarCurr,bitIndex1) )
      & ( v6878(VarCurr,bitIndex28)
      <=> v6879(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1737,axiom,
    ! [VarCurr] :
      ( v6878(VarCurr,bitIndex36)
    <=> v6632(VarCurr) ) ).

fof(addAssignment_1736,axiom,
    ! [VarCurr] :
      ( ( v6878(VarCurr,bitIndex46)
      <=> v6601(VarCurr,bitIndex9) )
      & ( v6878(VarCurr,bitIndex45)
      <=> v6601(VarCurr,bitIndex8) )
      & ( v6878(VarCurr,bitIndex44)
      <=> v6601(VarCurr,bitIndex7) )
      & ( v6878(VarCurr,bitIndex43)
      <=> v6601(VarCurr,bitIndex6) )
      & ( v6878(VarCurr,bitIndex42)
      <=> v6601(VarCurr,bitIndex5) )
      & ( v6878(VarCurr,bitIndex41)
      <=> v6601(VarCurr,bitIndex4) )
      & ( v6878(VarCurr,bitIndex40)
      <=> v6601(VarCurr,bitIndex3) )
      & ( v6878(VarCurr,bitIndex39)
      <=> v6601(VarCurr,bitIndex2) )
      & ( v6878(VarCurr,bitIndex38)
      <=> v6601(VarCurr,bitIndex1) )
      & ( v6878(VarCurr,bitIndex37)
      <=> v6601(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1735,axiom,
    ! [VarCurr] :
      ( ( v6878(VarCurr,bitIndex53)
      <=> v6576(VarCurr,bitIndex6) )
      & ( v6878(VarCurr,bitIndex52)
      <=> v6576(VarCurr,bitIndex5) )
      & ( v6878(VarCurr,bitIndex51)
      <=> v6576(VarCurr,bitIndex4) )
      & ( v6878(VarCurr,bitIndex50)
      <=> v6576(VarCurr,bitIndex3) )
      & ( v6878(VarCurr,bitIndex49)
      <=> v6576(VarCurr,bitIndex2) )
      & ( v6878(VarCurr,bitIndex48)
      <=> v6576(VarCurr,bitIndex1) )
      & ( v6878(VarCurr,bitIndex47)
      <=> v6576(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1734,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v6879(VarCurr,B)
      <=> v6742(VarCurr,B) ) ) ).

fof(addAssignment_1733,axiom,
    ! [VarCurr] :
      ( ( v6879(VarCurr,bitIndex7)
      <=> $false )
      & ( v6879(VarCurr,bitIndex6)
      <=> $false )
      & ( v6879(VarCurr,bitIndex5)
      <=> $false )
      & ( v6879(VarCurr,bitIndex4)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1250,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6866(VarNext)
      <=> ( v6867(VarNext)
          & v6874(VarNext) ) ) ) ).

fof(addAssignment_1732,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6874(VarNext)
      <=> v6872(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1249,axiom,
    ! [VarCurr] :
      ( v6872(VarCurr)
    <=> ( v6859(VarCurr)
        | v5397(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1248,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6867(VarNext)
      <=> ( v6869(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_585,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6869(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValue_76,axiom,
    ~ v6574(constB0,bitIndex53) ).

fof(addAssignmentInitValue_75,axiom,
    ~ v6574(constB0,bitIndex52) ).

fof(addAssignmentInitValue_74,axiom,
    ~ v6574(constB0,bitIndex51) ).

fof(addAssignmentInitValue_73,axiom,
    ~ v6574(constB0,bitIndex50) ).

fof(addAssignmentInitValue_72,axiom,
    ~ v6574(constB0,bitIndex49) ).

fof(addAssignmentInitValue_71,axiom,
    ~ v6574(constB0,bitIndex48) ).

fof(addAssignmentInitValue_70,axiom,
    ~ v6574(constB0,bitIndex47) ).

fof(addAssignmentInitValue_69,axiom,
    ~ v6574(constB0,bitIndex36) ).

fof(addAssignmentInitValue_68,axiom,
    ~ v6574(constB0,bitIndex32) ).

fof(bitBlastConstant_556,axiom,
    ~ b0000000xxxxxxxxxx0xxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex53) ).

fof(bitBlastConstant_555,axiom,
    ~ b0000000xxxxxxxxxx0xxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex52) ).

fof(bitBlastConstant_554,axiom,
    ~ b0000000xxxxxxxxxx0xxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex51) ).

fof(bitBlastConstant_553,axiom,
    ~ b0000000xxxxxxxxxx0xxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex50) ).

fof(bitBlastConstant_552,axiom,
    ~ b0000000xxxxxxxxxx0xxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex49) ).

fof(bitBlastConstant_551,axiom,
    ~ b0000000xxxxxxxxxx0xxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex48) ).

fof(bitBlastConstant_550,axiom,
    ~ b0000000xxxxxxxxxx0xxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex47) ).

fof(bitBlastConstant_549,axiom,
    ~ b0000000xxxxxxxxxx0xxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex36) ).

fof(bitBlastConstant_548,axiom,
    ~ b0000000xxxxxxxxxx0xxx0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex32) ).

fof(addParallelCaseBooleanConditionEqualRanges2_62,axiom,
    ! [VarCurr] :
      ( ( ~ v6861(VarCurr)
        & ~ v5385(VarCurr) )
     => ( v6859(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_149,axiom,
    ! [VarCurr] :
      ( v5385(VarCurr)
     => ( v6859(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_141,axiom,
    ! [VarCurr] :
      ( v6861(VarCurr)
     => ( v6859(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1247,axiom,
    ! [VarCurr] :
      ( v6861(VarCurr)
    <=> ( v5377(VarCurr)
        | v5381(VarCurr) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_119,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6844(VarNext)
       => ! [B] :
            ( range_5_0(B)
           => ( v6828(VarNext,B)
            <=> v6828(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_128,axiom,
    ! [VarNext] :
      ( v6844(VarNext)
     => ! [B] :
          ( range_5_0(B)
         => ( v6828(VarNext,B)
          <=> v6855(VarNext,B) ) ) ) ).

fof(addAssignment_1731,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_5_0(B)
         => ( v6855(VarNext,B)
          <=> v6853(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_176,axiom,
    ! [VarCurr] :
      ( ~ v4686(VarCurr)
     => ! [B] :
          ( range_5_0(B)
         => ( v6853(VarCurr,B)
          <=> v6831(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_178,axiom,
    ! [VarCurr] :
      ( v4686(VarCurr)
     => ! [B] :
          ( range_5_0(B)
         => ( v6853(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1246,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6844(VarNext)
      <=> ( v6845(VarNext)
          & v6852(VarNext) ) ) ) ).

fof(addAssignment_1730,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6852(VarNext)
      <=> v6850(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1245,axiom,
    ! [VarCurr] :
      ( v6850(VarCurr)
    <=> ( v67(VarCurr)
        | v4686(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1244,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6845(VarNext)
      <=> ( v6847(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_584,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6847(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_148,axiom,
    ! [VarCurr] :
      ( ~ v6841(VarCurr)
     => ! [B] :
          ( range_5_0(B)
         => ( v6831(VarCurr,B)
          <=> $false ) ) ) ).

fof(bitBlastConstant_547,axiom,
    ~ b000000(bitIndex5) ).

fof(bitBlastConstant_546,axiom,
    ~ b000000(bitIndex4) ).

fof(bitBlastConstant_545,axiom,
    ~ b000000(bitIndex3) ).

fof(bitBlastConstant_544,axiom,
    ~ b000000(bitIndex2) ).

fof(bitBlastConstant_543,axiom,
    ~ b000000(bitIndex1) ).

fof(bitBlastConstant_542,axiom,
    ~ b000000(bitIndex0) ).

fof(addParallelCaseBooleanConditionEqualRanges0_140,axiom,
    ! [VarCurr] :
      ( v6841(VarCurr)
     => ! [B] :
          ( range_5_0(B)
         => ( v6831(VarCurr,B)
          <=> v6833(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1243,axiom,
    ! [VarCurr] :
      ( v6841(VarCurr)
    <=> ( v6582(VarCurr)
        | v4905(VarCurr) ) ) ).

fof(addAssignment_1729,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6833(VarCurr,B)
      <=> v6835(VarCurr,B) ) ) ).

fof(addAssignment_1728,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6835(VarCurr,B)
      <=> v6837(VarCurr,B) ) ) ).

fof(addAssignment_1727,axiom,
    ! [VarCurr] :
      ( ( v6837(VarCurr,bitIndex5)
      <=> v6839(VarCurr,bitIndex23) )
      & ( v6837(VarCurr,bitIndex4)
      <=> v6839(VarCurr,bitIndex22) )
      & ( v6837(VarCurr,bitIndex3)
      <=> v6839(VarCurr,bitIndex21) )
      & ( v6837(VarCurr,bitIndex2)
      <=> v6839(VarCurr,bitIndex20) )
      & ( v6837(VarCurr,bitIndex1)
      <=> v6839(VarCurr,bitIndex19) )
      & ( v6837(VarCurr,bitIndex0)
      <=> v6839(VarCurr,bitIndex18) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_118,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6813(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v6798(VarNext,B)
            <=> v6798(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_127,axiom,
    ! [VarNext] :
      ( v6813(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v6798(VarNext,B)
          <=> v6824(VarNext,B) ) ) ) ).

fof(addAssignment_1726,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v6824(VarNext,B)
          <=> v6822(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_175,axiom,
    ! [VarCurr] :
      ( ~ v4686(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6822(VarCurr,B)
          <=> v6800(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_177,axiom,
    ! [VarCurr] :
      ( v4686(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6822(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1242,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6813(VarNext)
      <=> ( v6814(VarNext)
          & v6821(VarNext) ) ) ) ).

fof(addAssignment_1725,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6821(VarNext)
      <=> v6819(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1241,axiom,
    ! [VarCurr] :
      ( v6819(VarCurr)
    <=> ( v67(VarCurr)
        | v4686(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1240,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6814(VarNext)
      <=> ( v6816(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_583,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6816(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_147,axiom,
    ! [VarCurr] :
      ( ~ v6810(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6800(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_139,axiom,
    ! [VarCurr] :
      ( v6810(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6800(VarCurr,B)
          <=> v6802(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1239,axiom,
    ! [VarCurr] :
      ( v6810(VarCurr)
    <=> ( v6582(VarCurr)
        | v4905(VarCurr) ) ) ).

fof(addAssignment_1724,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6802(VarCurr,B)
      <=> v6804(VarCurr,B) ) ) ).

fof(addAssignment_1723,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6804(VarCurr,B)
      <=> v6806(VarCurr,B) ) ) ).

fof(addAssignment_1722,axiom,
    ! [VarCurr] :
      ( ( v6806(VarCurr,bitIndex4)
      <=> v6808(VarCurr,bitIndex19) )
      & ( v6806(VarCurr,bitIndex3)
      <=> v6808(VarCurr,bitIndex18) )
      & ( v6806(VarCurr,bitIndex2)
      <=> v6808(VarCurr,bitIndex17) )
      & ( v6806(VarCurr,bitIndex1)
      <=> v6808(VarCurr,bitIndex16) )
      & ( v6806(VarCurr,bitIndex0)
      <=> v6808(VarCurr,bitIndex15) ) ) ).

fof(addAssignment_1721,axiom,
    ! [VarNext,B] :
      ( range_11_0(B)
     => ( v6767(VarNext,B)
      <=> v6782(VarNext,B) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_117,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6783(VarNext)
       => ! [B] :
            ( range_33_0(B)
           => ( v6782(VarNext,B)
            <=> v6767(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_126,axiom,
    ! [VarNext] :
      ( v6783(VarNext)
     => ! [B] :
          ( range_33_0(B)
         => ( v6782(VarNext,B)
          <=> v6794(VarNext,B) ) ) ) ).

fof(addAssignment_1720,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_33_0(B)
         => ( v6794(VarNext,B)
          <=> v6792(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_174,axiom,
    ! [VarCurr] :
      ( ~ v4686(VarCurr)
     => ! [B] :
          ( range_33_0(B)
         => ( v6792(VarCurr,B)
          <=> v6770(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_176,axiom,
    ! [VarCurr] :
      ( v4686(VarCurr)
     => ! [B] :
          ( range_33_0(B)
         => ( v6792(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1238,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6783(VarNext)
      <=> ( v6784(VarNext)
          & v6791(VarNext) ) ) ) ).

fof(addAssignment_1719,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6791(VarNext)
      <=> v6789(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1237,axiom,
    ! [VarCurr] :
      ( v6789(VarCurr)
    <=> ( v67(VarCurr)
        | v4686(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1236,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6784(VarNext)
      <=> ( v6786(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_582,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6786(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignment_1718,axiom,
    ! [VarCurr,B] :
      ( range_11_0(B)
     => ( v6770(VarCurr,B)
      <=> v6779(VarCurr,B) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_146,axiom,
    ! [VarCurr] :
      ( ~ v6780(VarCurr)
     => ! [B] :
          ( range_33_0(B)
         => ( v6779(VarCurr,B)
          <=> $false ) ) ) ).

fof(bitBlastConstant_541,axiom,
    ~ b0000000000000000000000000000000000(bitIndex33) ).

fof(bitBlastConstant_540,axiom,
    ~ b0000000000000000000000000000000000(bitIndex32) ).

fof(bitBlastConstant_539,axiom,
    ~ b0000000000000000000000000000000000(bitIndex31) ).

fof(bitBlastConstant_538,axiom,
    ~ b0000000000000000000000000000000000(bitIndex30) ).

fof(bitBlastConstant_537,axiom,
    ~ b0000000000000000000000000000000000(bitIndex29) ).

fof(bitBlastConstant_536,axiom,
    ~ b0000000000000000000000000000000000(bitIndex28) ).

fof(bitBlastConstant_535,axiom,
    ~ b0000000000000000000000000000000000(bitIndex27) ).

fof(bitBlastConstant_534,axiom,
    ~ b0000000000000000000000000000000000(bitIndex26) ).

fof(bitBlastConstant_533,axiom,
    ~ b0000000000000000000000000000000000(bitIndex25) ).

fof(bitBlastConstant_532,axiom,
    ~ b0000000000000000000000000000000000(bitIndex24) ).

fof(bitBlastConstant_531,axiom,
    ~ b0000000000000000000000000000000000(bitIndex23) ).

fof(bitBlastConstant_530,axiom,
    ~ b0000000000000000000000000000000000(bitIndex22) ).

fof(bitBlastConstant_529,axiom,
    ~ b0000000000000000000000000000000000(bitIndex21) ).

fof(bitBlastConstant_528,axiom,
    ~ b0000000000000000000000000000000000(bitIndex20) ).

fof(bitBlastConstant_527,axiom,
    ~ b0000000000000000000000000000000000(bitIndex19) ).

fof(bitBlastConstant_526,axiom,
    ~ b0000000000000000000000000000000000(bitIndex18) ).

fof(bitBlastConstant_525,axiom,
    ~ b0000000000000000000000000000000000(bitIndex17) ).

fof(bitBlastConstant_524,axiom,
    ~ b0000000000000000000000000000000000(bitIndex16) ).

fof(bitBlastConstant_523,axiom,
    ~ b0000000000000000000000000000000000(bitIndex15) ).

fof(bitBlastConstant_522,axiom,
    ~ b0000000000000000000000000000000000(bitIndex14) ).

fof(bitBlastConstant_521,axiom,
    ~ b0000000000000000000000000000000000(bitIndex13) ).

fof(bitBlastConstant_520,axiom,
    ~ b0000000000000000000000000000000000(bitIndex12) ).

fof(bitBlastConstant_519,axiom,
    ~ b0000000000000000000000000000000000(bitIndex11) ).

fof(bitBlastConstant_518,axiom,
    ~ b0000000000000000000000000000000000(bitIndex10) ).

fof(bitBlastConstant_517,axiom,
    ~ b0000000000000000000000000000000000(bitIndex9) ).

fof(bitBlastConstant_516,axiom,
    ~ b0000000000000000000000000000000000(bitIndex8) ).

fof(bitBlastConstant_515,axiom,
    ~ b0000000000000000000000000000000000(bitIndex7) ).

fof(bitBlastConstant_514,axiom,
    ~ b0000000000000000000000000000000000(bitIndex6) ).

fof(bitBlastConstant_513,axiom,
    ~ b0000000000000000000000000000000000(bitIndex5) ).

fof(bitBlastConstant_512,axiom,
    ~ b0000000000000000000000000000000000(bitIndex4) ).

fof(bitBlastConstant_511,axiom,
    ~ b0000000000000000000000000000000000(bitIndex3) ).

fof(bitBlastConstant_510,axiom,
    ~ b0000000000000000000000000000000000(bitIndex2) ).

fof(bitBlastConstant_509,axiom,
    ~ b0000000000000000000000000000000000(bitIndex1) ).

fof(bitBlastConstant_508,axiom,
    ~ b0000000000000000000000000000000000(bitIndex0) ).

fof(addParallelCaseBooleanConditionEqualRanges0_138,axiom,
    ! [VarCurr] :
      ( v6780(VarCurr)
     => ! [B] :
          ( range_33_0(B)
         => ( v6779(VarCurr,B)
          <=> v6772(VarCurr,B) ) ) ) ).

fof(range_axiom_45,axiom,
    ! [B] :
      ( range_33_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B
        | bitIndex11 = B
        | bitIndex12 = B
        | bitIndex13 = B
        | bitIndex14 = B
        | bitIndex15 = B
        | bitIndex16 = B
        | bitIndex17 = B
        | bitIndex18 = B
        | bitIndex19 = B
        | bitIndex20 = B
        | bitIndex21 = B
        | bitIndex22 = B
        | bitIndex23 = B
        | bitIndex24 = B
        | bitIndex25 = B
        | bitIndex26 = B
        | bitIndex27 = B
        | bitIndex28 = B
        | bitIndex29 = B
        | bitIndex30 = B
        | bitIndex31 = B
        | bitIndex32 = B
        | bitIndex33 = B ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1235,axiom,
    ! [VarCurr] :
      ( v6780(VarCurr)
    <=> ( v6582(VarCurr)
        | v4905(VarCurr) ) ) ).

fof(addAssignment_1717,axiom,
    ! [VarCurr,B] :
      ( range_11_0(B)
     => ( v6772(VarCurr,B)
      <=> v6774(VarCurr,B) ) ) ).

fof(addAssignment_1716,axiom,
    ! [VarCurr,B] :
      ( range_11_0(B)
     => ( v6774(VarCurr,B)
      <=> v6776(VarCurr,B) ) ) ).

fof(range_axiom_44,axiom,
    ! [B] :
      ( range_11_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B
        | bitIndex11 = B ) ) ).

fof(addAssignment_1715,axiom,
    ! [VarCurr] :
      ( ( v6776(VarCurr,bitIndex11)
      <=> v6778(VarCurr,bitIndex113) )
      & ( v6776(VarCurr,bitIndex10)
      <=> v6778(VarCurr,bitIndex112) )
      & ( v6776(VarCurr,bitIndex9)
      <=> v6778(VarCurr,bitIndex111) )
      & ( v6776(VarCurr,bitIndex8)
      <=> v6778(VarCurr,bitIndex110) )
      & ( v6776(VarCurr,bitIndex7)
      <=> v6778(VarCurr,bitIndex109) )
      & ( v6776(VarCurr,bitIndex6)
      <=> v6778(VarCurr,bitIndex108) )
      & ( v6776(VarCurr,bitIndex5)
      <=> v6778(VarCurr,bitIndex107) )
      & ( v6776(VarCurr,bitIndex4)
      <=> v6778(VarCurr,bitIndex106) )
      & ( v6776(VarCurr,bitIndex3)
      <=> v6778(VarCurr,bitIndex105) )
      & ( v6776(VarCurr,bitIndex2)
      <=> v6778(VarCurr,bitIndex104) )
      & ( v6776(VarCurr,bitIndex1)
      <=> v6778(VarCurr,bitIndex103) )
      & ( v6776(VarCurr,bitIndex0)
      <=> v6778(VarCurr,bitIndex102) ) ) ).

fof(addAssignment_1714,axiom,
    ! [VarNext,B] :
      ( range_3_0(B)
     => ( v6742(VarNext,B)
      <=> v6751(VarNext,B) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_116,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6752(VarNext)
       => ! [B] :
            ( range_7_0(B)
           => ( v6751(VarNext,B)
            <=> v6742(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_125,axiom,
    ! [VarNext] :
      ( v6752(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v6751(VarNext,B)
          <=> v6763(VarNext,B) ) ) ) ).

fof(addAssignment_1713,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v6763(VarNext,B)
          <=> v6761(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_173,axiom,
    ! [VarCurr] :
      ( ~ v4686(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v6761(VarCurr,B)
          <=> v6744(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_175,axiom,
    ! [VarCurr] :
      ( v4686(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v6761(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1234,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6752(VarNext)
      <=> ( v6753(VarNext)
          & v6760(VarNext) ) ) ) ).

fof(addAssignment_1712,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6760(VarNext)
      <=> v6758(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1233,axiom,
    ! [VarCurr] :
      ( v6758(VarCurr)
    <=> ( v67(VarCurr)
        | v4686(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1232,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6753(VarNext)
      <=> ( v6755(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_581,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6755(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValue_67,axiom,
    ~ v6742(constB0,bitIndex4) ).

fof(bitBlastConstant_507,axiom,
    ~ bxxx0xxxx(bitIndex4) ).

fof(addAssignment_1711,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v6744(VarCurr,B)
      <=> v6745(VarCurr,B) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_61,axiom,
    ! [VarCurr] :
      ( ( ~ v6746(VarCurr)
        & ~ v4905(VarCurr) )
     => ! [B] :
          ( range_7_0(B)
         => ( v6745(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_145,axiom,
    ! [VarCurr] :
      ( v4905(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v6745(VarCurr,B)
          <=> v6747(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_137,axiom,
    ! [VarCurr] :
      ( v6746(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v6745(VarCurr,B)
          <=> v4278(VarCurr,B) ) ) ) ).

fof(addAssignment_1710,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v6747(VarCurr,B)
      <=> v4278(VarCurr,B) ) ) ).

fof(addAssignment_1709,axiom,
    ! [VarCurr] :
      ( v6747(VarCurr,bitIndex4)
    <=> $true ) ).

fof(addAssignment_1708,axiom,
    ! [VarCurr,B] :
      ( range_7_5(B)
     => ( v6747(VarCurr,B)
      <=> v4278(VarCurr,B) ) ) ).

fof(addAssignment_1707,axiom,
    ! [VarCurr] :
      ( v6746(VarCurr)
    <=> v6582(VarCurr) ) ).

fof(addAssignment_1706,axiom,
    ! [VarCurr] :
      ( v4278(VarCurr,bitIndex3)
    <=> v4280(VarCurr,bitIndex3) ) ).

fof(addAssignment_1705,axiom,
    ! [VarCurr] :
      ( v4280(VarCurr,bitIndex3)
    <=> v4282(VarCurr,bitIndex3) ) ).

fof(addAssignment_1704,axiom,
    ! [VarCurr] :
      ( v4282(VarCurr,bitIndex3)
    <=> v4284(VarCurr,bitIndex27) ) ).

fof(addCaseBooleanConditionEqualRanges1_115,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6635(VarNext)
       => ( v6632(VarNext)
        <=> v6632(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_124,axiom,
    ! [VarNext] :
      ( v6635(VarNext)
     => ( v6632(VarNext)
      <=> v6643(VarNext) ) ) ).

fof(addAssignment_1703,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6643(VarNext)
      <=> v6641(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_172,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ( v6641(VarCurr)
      <=> v6644(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_174,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ( v6641(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_171,axiom,
    ! [VarCurr] :
      ( ~ v6645(VarCurr)
     => ( v6644(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_173,axiom,
    ! [VarCurr] :
      ( v6645(VarCurr)
     => ( v6644(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_408,axiom,
    ! [VarCurr] :
      ( v6645(VarCurr)
    <=> ( ( v6646(VarCurr,bitIndex5)
        <=> $false )
        & ( v6646(VarCurr,bitIndex4)
        <=> $false )
        & ( v6646(VarCurr,bitIndex3)
        <=> $false )
        & ( v6646(VarCurr,bitIndex2)
        <=> $false )
        & ( v6646(VarCurr,bitIndex1)
        <=> $false )
        & ( v6646(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1702,axiom,
    ! [VarCurr] :
      ( v6646(VarCurr,bitIndex0)
    <=> v6735(VarCurr) ) ).

fof(addAssignment_1701,axiom,
    ! [VarCurr] :
      ( v6646(VarCurr,bitIndex1)
    <=> v6730(VarCurr) ) ).

fof(addAssignment_1700,axiom,
    ! [VarCurr] :
      ( v6646(VarCurr,bitIndex2)
    <=> v6725(VarCurr) ) ).

fof(addAssignment_1699,axiom,
    ! [VarCurr] :
      ( v6646(VarCurr,bitIndex3)
    <=> v6720(VarCurr) ) ).

fof(addAssignment_1698,axiom,
    ! [VarCurr] :
      ( v6646(VarCurr,bitIndex4)
    <=> v6715(VarCurr) ) ).

fof(addAssignment_1697,axiom,
    ! [VarCurr] :
      ( v6646(VarCurr,bitIndex5)
    <=> v6648(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1231,axiom,
    ! [VarCurr] :
      ( v6735(VarCurr)
    <=> ( v6736(VarCurr)
        & v6738(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_324,axiom,
    ! [VarCurr] :
      ( v6738(VarCurr)
    <=> ( v4699(VarCurr,bitIndex0)
        | v5625(VarCurr,bitIndex38) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1230,axiom,
    ! [VarCurr] :
      ( v6736(VarCurr)
    <=> ( v6666(VarCurr)
        | v6737(VarCurr) ) ) ).

fof(writeUnaryOperator_580,axiom,
    ! [VarCurr] :
      ( ~ v6737(VarCurr)
    <=> v5625(VarCurr,bitIndex38) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1229,axiom,
    ! [VarCurr] :
      ( v6730(VarCurr)
    <=> ( v6731(VarCurr)
        & v6734(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1228,axiom,
    ! [VarCurr] :
      ( v6734(VarCurr)
    <=> ( v6659(VarCurr)
        | v6660(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1227,axiom,
    ! [VarCurr] :
      ( v6731(VarCurr)
    <=> ( v6732(VarCurr)
        | v6733(VarCurr) ) ) ).

fof(writeUnaryOperator_579,axiom,
    ! [VarCurr] :
      ( ~ v6733(VarCurr)
    <=> v6660(VarCurr) ) ).

fof(writeUnaryOperator_578,axiom,
    ! [VarCurr] :
      ( ~ v6732(VarCurr)
    <=> v6659(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1226,axiom,
    ! [VarCurr] :
      ( v6725(VarCurr)
    <=> ( v6726(VarCurr)
        & v6729(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1225,axiom,
    ! [VarCurr] :
      ( v6729(VarCurr)
    <=> ( v6657(VarCurr)
        | v6671(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1224,axiom,
    ! [VarCurr] :
      ( v6726(VarCurr)
    <=> ( v6727(VarCurr)
        | v6728(VarCurr) ) ) ).

fof(writeUnaryOperator_577,axiom,
    ! [VarCurr] :
      ( ~ v6728(VarCurr)
    <=> v6671(VarCurr) ) ).

fof(writeUnaryOperator_576,axiom,
    ! [VarCurr] :
      ( ~ v6727(VarCurr)
    <=> v6657(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1223,axiom,
    ! [VarCurr] :
      ( v6720(VarCurr)
    <=> ( v6721(VarCurr)
        & v6724(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1222,axiom,
    ! [VarCurr] :
      ( v6724(VarCurr)
    <=> ( v6655(VarCurr)
        | v6683(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1221,axiom,
    ! [VarCurr] :
      ( v6721(VarCurr)
    <=> ( v6722(VarCurr)
        | v6723(VarCurr) ) ) ).

fof(writeUnaryOperator_575,axiom,
    ! [VarCurr] :
      ( ~ v6723(VarCurr)
    <=> v6683(VarCurr) ) ).

fof(writeUnaryOperator_574,axiom,
    ! [VarCurr] :
      ( ~ v6722(VarCurr)
    <=> v6655(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1220,axiom,
    ! [VarCurr] :
      ( v6715(VarCurr)
    <=> ( v6716(VarCurr)
        & v6719(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1219,axiom,
    ! [VarCurr] :
      ( v6719(VarCurr)
    <=> ( v6653(VarCurr)
        | v6695(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1218,axiom,
    ! [VarCurr] :
      ( v6716(VarCurr)
    <=> ( v6717(VarCurr)
        | v6718(VarCurr) ) ) ).

fof(writeUnaryOperator_573,axiom,
    ! [VarCurr] :
      ( ~ v6718(VarCurr)
    <=> v6695(VarCurr) ) ).

fof(writeUnaryOperator_572,axiom,
    ! [VarCurr] :
      ( ~ v6717(VarCurr)
    <=> v6653(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1217,axiom,
    ! [VarCurr] :
      ( v6648(VarCurr)
    <=> ( v6649(VarCurr)
        & v6714(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1216,axiom,
    ! [VarCurr] :
      ( v6714(VarCurr)
    <=> ( v6651(VarCurr)
        | v6708(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1215,axiom,
    ! [VarCurr] :
      ( v6649(VarCurr)
    <=> ( v6650(VarCurr)
        | v6707(VarCurr) ) ) ).

fof(writeUnaryOperator_571,axiom,
    ! [VarCurr] :
      ( ~ v6707(VarCurr)
    <=> v6708(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1214,axiom,
    ! [VarCurr] :
      ( v6708(VarCurr)
    <=> ( v6709(VarCurr)
        & v6712(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_323,axiom,
    ! [VarCurr] :
      ( v6712(VarCurr)
    <=> ( v6713(VarCurr)
        | v5625(VarCurr,bitIndex43) ) ) ).

fof(writeUnaryOperator_570,axiom,
    ! [VarCurr] :
      ( ~ v6713(VarCurr)
    <=> v6710(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1213,axiom,
    ! [VarCurr] :
      ( v6709(VarCurr)
    <=> ( v6710(VarCurr)
        | v6711(VarCurr) ) ) ).

fof(writeUnaryOperator_569,axiom,
    ! [VarCurr] :
      ( ~ v6711(VarCurr)
    <=> v5625(VarCurr,bitIndex43) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1212,axiom,
    ! [VarCurr] :
      ( v6710(VarCurr)
    <=> ( v6701(VarCurr)
        & v6703(VarCurr) ) ) ).

fof(writeUnaryOperator_568,axiom,
    ! [VarCurr] :
      ( ~ v6650(VarCurr)
    <=> v6651(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1211,axiom,
    ! [VarCurr] :
      ( v6651(VarCurr)
    <=> ( v6652(VarCurr)
        | v6706(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_322,axiom,
    ! [VarCurr] :
      ( v6706(VarCurr)
    <=> ( v6698(VarCurr)
        & v5625(VarCurr,bitIndex42) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1210,axiom,
    ! [VarCurr] :
      ( v6652(VarCurr)
    <=> ( v6653(VarCurr)
        & v6695(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1209,axiom,
    ! [VarCurr] :
      ( v6695(VarCurr)
    <=> ( v6696(VarCurr)
        & v6705(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_321,axiom,
    ! [VarCurr] :
      ( v6705(VarCurr)
    <=> ( v6698(VarCurr)
        | v5625(VarCurr,bitIndex42) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1208,axiom,
    ! [VarCurr] :
      ( v6696(VarCurr)
    <=> ( v6697(VarCurr)
        | v6704(VarCurr) ) ) ).

fof(writeUnaryOperator_567,axiom,
    ! [VarCurr] :
      ( ~ v6704(VarCurr)
    <=> v5625(VarCurr,bitIndex42) ) ).

fof(writeUnaryOperator_566,axiom,
    ! [VarCurr] :
      ( ~ v6697(VarCurr)
    <=> v6698(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1207,axiom,
    ! [VarCurr] :
      ( v6698(VarCurr)
    <=> ( v6699(VarCurr)
        & v6702(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1206,axiom,
    ! [VarCurr] :
      ( v6702(VarCurr)
    <=> ( v6701(VarCurr)
        | v6703(VarCurr) ) ) ).

fof(writeUnaryOperator_565,axiom,
    ! [VarCurr] :
      ( ~ v6703(VarCurr)
    <=> v4699(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_320,axiom,
    ! [VarCurr] :
      ( v6699(VarCurr)
    <=> ( v6700(VarCurr)
        | v4699(VarCurr,bitIndex4) ) ) ).

fof(writeUnaryOperator_564,axiom,
    ! [VarCurr] :
      ( ~ v6700(VarCurr)
    <=> v6701(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1205,axiom,
    ! [VarCurr] :
      ( v6701(VarCurr)
    <=> ( v6689(VarCurr)
        & v6691(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1204,axiom,
    ! [VarCurr] :
      ( v6653(VarCurr)
    <=> ( v6654(VarCurr)
        | v6694(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_319,axiom,
    ! [VarCurr] :
      ( v6694(VarCurr)
    <=> ( v6686(VarCurr)
        & v5625(VarCurr,bitIndex41) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1203,axiom,
    ! [VarCurr] :
      ( v6654(VarCurr)
    <=> ( v6655(VarCurr)
        & v6683(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1202,axiom,
    ! [VarCurr] :
      ( v6683(VarCurr)
    <=> ( v6684(VarCurr)
        & v6693(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_318,axiom,
    ! [VarCurr] :
      ( v6693(VarCurr)
    <=> ( v6686(VarCurr)
        | v5625(VarCurr,bitIndex41) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1201,axiom,
    ! [VarCurr] :
      ( v6684(VarCurr)
    <=> ( v6685(VarCurr)
        | v6692(VarCurr) ) ) ).

fof(writeUnaryOperator_563,axiom,
    ! [VarCurr] :
      ( ~ v6692(VarCurr)
    <=> v5625(VarCurr,bitIndex41) ) ).

fof(writeUnaryOperator_562,axiom,
    ! [VarCurr] :
      ( ~ v6685(VarCurr)
    <=> v6686(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1200,axiom,
    ! [VarCurr] :
      ( v6686(VarCurr)
    <=> ( v6687(VarCurr)
        & v6690(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1199,axiom,
    ! [VarCurr] :
      ( v6690(VarCurr)
    <=> ( v6689(VarCurr)
        | v6691(VarCurr) ) ) ).

fof(writeUnaryOperator_561,axiom,
    ! [VarCurr] :
      ( ~ v6691(VarCurr)
    <=> v4699(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_317,axiom,
    ! [VarCurr] :
      ( v6687(VarCurr)
    <=> ( v6688(VarCurr)
        | v4699(VarCurr,bitIndex3) ) ) ).

fof(writeUnaryOperator_560,axiom,
    ! [VarCurr] :
      ( ~ v6688(VarCurr)
    <=> v6689(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1198,axiom,
    ! [VarCurr] :
      ( v6689(VarCurr)
    <=> ( v6677(VarCurr)
        & v6679(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1197,axiom,
    ! [VarCurr] :
      ( v6655(VarCurr)
    <=> ( v6656(VarCurr)
        | v6682(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_316,axiom,
    ! [VarCurr] :
      ( v6682(VarCurr)
    <=> ( v6674(VarCurr)
        & v5625(VarCurr,bitIndex40) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1196,axiom,
    ! [VarCurr] :
      ( v6656(VarCurr)
    <=> ( v6657(VarCurr)
        & v6671(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1195,axiom,
    ! [VarCurr] :
      ( v6671(VarCurr)
    <=> ( v6672(VarCurr)
        & v6681(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_315,axiom,
    ! [VarCurr] :
      ( v6681(VarCurr)
    <=> ( v6674(VarCurr)
        | v5625(VarCurr,bitIndex40) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1194,axiom,
    ! [VarCurr] :
      ( v6672(VarCurr)
    <=> ( v6673(VarCurr)
        | v6680(VarCurr) ) ) ).

fof(writeUnaryOperator_559,axiom,
    ! [VarCurr] :
      ( ~ v6680(VarCurr)
    <=> v5625(VarCurr,bitIndex40) ) ).

fof(writeUnaryOperator_558,axiom,
    ! [VarCurr] :
      ( ~ v6673(VarCurr)
    <=> v6674(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1193,axiom,
    ! [VarCurr] :
      ( v6674(VarCurr)
    <=> ( v6675(VarCurr)
        & v6678(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1192,axiom,
    ! [VarCurr] :
      ( v6678(VarCurr)
    <=> ( v6677(VarCurr)
        | v6679(VarCurr) ) ) ).

fof(writeUnaryOperator_557,axiom,
    ! [VarCurr] :
      ( ~ v6679(VarCurr)
    <=> v4699(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges_314,axiom,
    ! [VarCurr] :
      ( v6675(VarCurr)
    <=> ( v6676(VarCurr)
        | v4699(VarCurr,bitIndex2) ) ) ).

fof(writeUnaryOperator_556,axiom,
    ! [VarCurr] :
      ( ~ v6676(VarCurr)
    <=> v6677(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1191,axiom,
    ! [VarCurr] :
      ( v6677(VarCurr)
    <=> ( v6666(VarCurr)
        & v6667(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1190,axiom,
    ! [VarCurr] :
      ( v6657(VarCurr)
    <=> ( v6658(VarCurr)
        | v6670(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_313,axiom,
    ! [VarCurr] :
      ( v6670(VarCurr)
    <=> ( v6663(VarCurr)
        & v5625(VarCurr,bitIndex39) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1189,axiom,
    ! [VarCurr] :
      ( v6658(VarCurr)
    <=> ( v6659(VarCurr)
        & v6660(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1188,axiom,
    ! [VarCurr] :
      ( v6660(VarCurr)
    <=> ( v6661(VarCurr)
        & v6669(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_312,axiom,
    ! [VarCurr] :
      ( v6669(VarCurr)
    <=> ( v6663(VarCurr)
        | v5625(VarCurr,bitIndex39) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1187,axiom,
    ! [VarCurr] :
      ( v6661(VarCurr)
    <=> ( v6662(VarCurr)
        | v6668(VarCurr) ) ) ).

fof(writeUnaryOperator_555,axiom,
    ! [VarCurr] :
      ( ~ v6668(VarCurr)
    <=> v5625(VarCurr,bitIndex39) ) ).

fof(writeUnaryOperator_554,axiom,
    ! [VarCurr] :
      ( ~ v6662(VarCurr)
    <=> v6663(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1186,axiom,
    ! [VarCurr] :
      ( v6663(VarCurr)
    <=> ( v6664(VarCurr)
        & v6665(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1185,axiom,
    ! [VarCurr] :
      ( v6665(VarCurr)
    <=> ( v6666(VarCurr)
        | v6667(VarCurr) ) ) ).

fof(writeUnaryOperator_553,axiom,
    ! [VarCurr] :
      ( ~ v6667(VarCurr)
    <=> v4699(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_552,axiom,
    ! [VarCurr] :
      ( ~ v6666(VarCurr)
    <=> v4699(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorShiftedRanges_311,axiom,
    ! [VarCurr] :
      ( v6664(VarCurr)
    <=> ( v4699(VarCurr,bitIndex0)
        | v4699(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorShiftedRanges_310,axiom,
    ! [VarCurr] :
      ( v6659(VarCurr)
    <=> ( v4699(VarCurr,bitIndex0)
        & v5625(VarCurr,bitIndex38) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1184,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6635(VarNext)
      <=> v6636(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1183,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6636(VarNext)
      <=> ( v6638(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_551,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6638(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValueVector_30,axiom,
    ( v6632(constB0)
  <=> $false ) ).

fof(addCaseBooleanConditionEqualRanges1_114,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6617(VarNext)
       => ! [B] :
            ( range_9_0(B)
           => ( v6601(VarNext,B)
            <=> v6601(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_123,axiom,
    ! [VarNext] :
      ( v6617(VarNext)
     => ! [B] :
          ( range_9_0(B)
         => ( v6601(VarNext,B)
          <=> v6628(VarNext,B) ) ) ) ).

fof(addAssignment_1696,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_9_0(B)
         => ( v6628(VarNext,B)
          <=> v6626(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_170,axiom,
    ! [VarCurr] :
      ( ~ v4686(VarCurr)
     => ! [B] :
          ( range_9_0(B)
         => ( v6626(VarCurr,B)
          <=> v6604(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_172,axiom,
    ! [VarCurr] :
      ( v4686(VarCurr)
     => ! [B] :
          ( range_9_0(B)
         => ( v6626(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1182,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6617(VarNext)
      <=> ( v6618(VarNext)
          & v6625(VarNext) ) ) ) ).

fof(addAssignment_1695,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6625(VarNext)
      <=> v6623(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1181,axiom,
    ! [VarCurr] :
      ( v6623(VarCurr)
    <=> ( v67(VarCurr)
        | v4686(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1180,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6618(VarNext)
      <=> ( v6620(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_550,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6620(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_144,axiom,
    ! [VarCurr] :
      ( ~ v6614(VarCurr)
     => ! [B] :
          ( range_9_0(B)
         => ( v6604(VarCurr,B)
          <=> $false ) ) ) ).

fof(bitBlastConstant_506,axiom,
    ~ b0000000000(bitIndex9) ).

fof(bitBlastConstant_505,axiom,
    ~ b0000000000(bitIndex8) ).

fof(bitBlastConstant_504,axiom,
    ~ b0000000000(bitIndex7) ).

fof(bitBlastConstant_503,axiom,
    ~ b0000000000(bitIndex6) ).

fof(bitBlastConstant_502,axiom,
    ~ b0000000000(bitIndex5) ).

fof(bitBlastConstant_501,axiom,
    ~ b0000000000(bitIndex4) ).

fof(bitBlastConstant_500,axiom,
    ~ b0000000000(bitIndex3) ).

fof(bitBlastConstant_499,axiom,
    ~ b0000000000(bitIndex2) ).

fof(bitBlastConstant_498,axiom,
    ~ b0000000000(bitIndex1) ).

fof(bitBlastConstant_497,axiom,
    ~ b0000000000(bitIndex0) ).

fof(addParallelCaseBooleanConditionEqualRanges0_136,axiom,
    ! [VarCurr] :
      ( v6614(VarCurr)
     => ! [B] :
          ( range_9_0(B)
         => ( v6604(VarCurr,B)
          <=> v6606(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1179,axiom,
    ! [VarCurr] :
      ( v6614(VarCurr)
    <=> ( v6582(VarCurr)
        | v4905(VarCurr) ) ) ).

fof(addAssignment_1694,axiom,
    ! [VarCurr,B] :
      ( range_9_0(B)
     => ( v6606(VarCurr,B)
      <=> v6608(VarCurr,B) ) ) ).

fof(addAssignment_1693,axiom,
    ! [VarCurr,B] :
      ( range_9_0(B)
     => ( v6608(VarCurr,B)
      <=> v6610(VarCurr,B) ) ) ).

fof(range_axiom_43,axiom,
    ! [B] :
      ( range_9_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B ) ) ).

fof(addAssignment_1692,axiom,
    ! [VarCurr] :
      ( ( v6610(VarCurr,bitIndex9)
      <=> v6612(VarCurr,bitIndex39) )
      & ( v6610(VarCurr,bitIndex8)
      <=> v6612(VarCurr,bitIndex38) )
      & ( v6610(VarCurr,bitIndex7)
      <=> v6612(VarCurr,bitIndex37) )
      & ( v6610(VarCurr,bitIndex6)
      <=> v6612(VarCurr,bitIndex36) )
      & ( v6610(VarCurr,bitIndex5)
      <=> v6612(VarCurr,bitIndex35) )
      & ( v6610(VarCurr,bitIndex4)
      <=> v6612(VarCurr,bitIndex34) )
      & ( v6610(VarCurr,bitIndex3)
      <=> v6612(VarCurr,bitIndex33) )
      & ( v6610(VarCurr,bitIndex2)
      <=> v6612(VarCurr,bitIndex32) )
      & ( v6610(VarCurr,bitIndex1)
      <=> v6612(VarCurr,bitIndex31) )
      & ( v6610(VarCurr,bitIndex0)
      <=> v6612(VarCurr,bitIndex30) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_113,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6586(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v6576(VarNext,B)
            <=> v6576(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_122,axiom,
    ! [VarNext] :
      ( v6586(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v6576(VarNext,B)
          <=> v6597(VarNext,B) ) ) ) ).

fof(addAssignment_1691,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v6597(VarNext,B)
          <=> v6595(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_169,axiom,
    ! [VarCurr] :
      ( ~ v4686(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v6595(VarCurr,B)
          <=> v6578(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_171,axiom,
    ! [VarCurr] :
      ( v4686(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v6595(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1178,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6586(VarNext)
      <=> ( v6587(VarNext)
          & v6594(VarNext) ) ) ) ).

fof(addAssignment_1690,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6594(VarNext)
      <=> v6592(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1177,axiom,
    ! [VarCurr] :
      ( v6592(VarCurr)
    <=> ( v67(VarCurr)
        | v4686(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1176,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6587(VarNext)
      <=> ( v6589(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_549,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6589(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValueVector_29,axiom,
    ! [B] :
      ( range_6_0(B)
     => ( v6576(constB0,B)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_143,axiom,
    ! [VarCurr] :
      ( ~ v6580(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v6578(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_135,axiom,
    ! [VarCurr] :
      ( v6580(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v6578(VarCurr,B)
          <=> v3196(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1175,axiom,
    ! [VarCurr] :
      ( v6580(VarCurr)
    <=> ( v6582(VarCurr)
        | v4905(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1174,axiom,
    ! [VarCurr] :
      ( v6582(VarCurr)
    <=> ( v6583(VarCurr)
        | v4902(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1173,axiom,
    ! [VarCurr] :
      ( v6583(VarCurr)
    <=> ( v4899(VarCurr)
        | v4900(VarCurr) ) ) ).

fof(addAssignment_1689,axiom,
    ! [VarCurr] :
      ( v6566(VarCurr)
    <=> v4942(VarCurr) ) ).

fof(addAssignment_1688,axiom,
    ! [VarCurr] :
      ( v6563(VarCurr)
    <=> v4937(VarCurr) ) ).

fof(addAssignment_1687,axiom,
    ! [VarNext,B] :
      ( range_43_32(B)
     => ( v5625(VarNext,B)
      <=> v6533(VarNext,B) ) ) ).

fof(range_axiom_42,axiom,
    ! [B] :
      ( range_43_32(B)
    <=> ( $false
        | bitIndex32 = B
        | bitIndex33 = B
        | bitIndex34 = B
        | bitIndex35 = B
        | bitIndex36 = B
        | bitIndex37 = B
        | bitIndex38 = B
        | bitIndex39 = B
        | bitIndex40 = B
        | bitIndex41 = B
        | bitIndex42 = B
        | bitIndex43 = B ) ) ).

fof(addCaseBooleanConditionEqualRanges1_112,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6534(VarNext)
       => ! [B] :
            ( range_43_0(B)
           => ( v6533(VarNext,B)
            <=> v5625(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_121,axiom,
    ! [VarNext] :
      ( v6534(VarNext)
     => ! [B] :
          ( range_43_0(B)
         => ( v6533(VarNext,B)
          <=> v6545(VarNext,B) ) ) ) ).

fof(addAssignment_1686,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_43_0(B)
         => ( v6545(VarNext,B)
          <=> v6543(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_168,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ! [B] :
          ( range_43_0(B)
         => ( v6543(VarCurr,B)
          <=> v4925(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_170,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ! [B] :
          ( range_43_0(B)
         => ( v6543(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1172,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6534(VarNext)
      <=> ( v6535(VarNext)
          & v6542(VarNext) ) ) ) ).

fof(addAssignment_1685,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6542(VarNext)
      <=> v6540(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1171,axiom,
    ! [VarCurr] :
      ( v6540(VarCurr)
    <=> ( v6289(VarCurr)
        | v5397(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1170,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6535(VarNext)
      <=> ( v6537(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_548,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6537(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValue_66,axiom,
    ~ v5625(constB0,bitIndex43) ).

fof(addAssignmentInitValue_65,axiom,
    ~ v5625(constB0,bitIndex42) ).

fof(addAssignmentInitValue_64,axiom,
    ~ v5625(constB0,bitIndex41) ).

fof(addAssignmentInitValue_63,axiom,
    ~ v5625(constB0,bitIndex40) ).

fof(addAssignmentInitValue_62,axiom,
    ~ v5625(constB0,bitIndex39) ).

fof(addAssignmentInitValue_61,axiom,
    ~ v5625(constB0,bitIndex38) ).

fof(bitBlastConstant_496,axiom,
    ~ b000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex43) ).

fof(bitBlastConstant_495,axiom,
    ~ b000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex42) ).

fof(bitBlastConstant_494,axiom,
    ~ b000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex41) ).

fof(bitBlastConstant_493,axiom,
    ~ b000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex40) ).

fof(bitBlastConstant_492,axiom,
    ~ b000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex39) ).

fof(bitBlastConstant_491,axiom,
    ~ b000000xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(bitIndex38) ).

fof(addAssignment_1684,axiom,
    ! [VarCurr,B] :
      ( range_37_32(B)
     => ( v4925(VarCurr,B)
      <=> v4927(VarCurr,B) ) ) ).

fof(addAssignment_1683,axiom,
    ! [VarCurr,B] :
      ( range_37_32(B)
     => ( v4927(VarCurr,B)
      <=> v4929(VarCurr,B) ) ) ).

fof(addAssignment_1682,axiom,
    ! [VarCurr,B] :
      ( range_37_32(B)
     => ( v4929(VarCurr,B)
      <=> v4931(VarCurr,B) ) ) ).

fof(addAssignment_1681,axiom,
    ! [VarCurr,B] :
      ( range_37_32(B)
     => ( v4931(VarCurr,B)
      <=> v6529(VarCurr,B) ) ) ).

fof(range_axiom_41,axiom,
    ! [B] :
      ( range_37_32(B)
    <=> ( $false
        | bitIndex32 = B
        | bitIndex33 = B
        | bitIndex34 = B
        | bitIndex35 = B
        | bitIndex36 = B
        | bitIndex37 = B ) ) ).

fof(addAssignment_1680,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6281(VarCurr,B)
      <=> v6283(VarCurr,B) ) ) ).

fof(addAssignment_1679,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6283(VarCurr,B)
      <=> v6285(VarCurr,B) ) ) ).

fof(addAssignment_1678,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6285(VarCurr,B)
      <=> v6287(VarCurr,B) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_167,axiom,
    ! [VarCurr] :
      ( ~ v6524(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6287(VarCurr,B)
          <=> v6501(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_169,axiom,
    ! [VarCurr] :
      ( v6524(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6287(VarCurr,B)
          <=> v6302(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1169,axiom,
    ! [VarCurr] :
      ( v6524(VarCurr)
    <=> ( v6525(VarCurr)
        & v4666(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1168,axiom,
    ! [VarCurr] :
      ( v6525(VarCurr)
    <=> ( v6289(VarCurr)
        & v6526(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1167,axiom,
    ! [VarCurr] :
      ( v6526(VarCurr)
    <=> ( v6527(VarCurr)
        | v6528(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_407,axiom,
    ! [VarCurr] :
      ( v6528(VarCurr)
    <=> ( ( v4672(VarCurr,bitIndex2)
        <=> $false )
        & ( v4672(VarCurr,bitIndex1)
        <=> $true )
        & ( v4672(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_406,axiom,
    ! [VarCurr] :
      ( v6527(VarCurr)
    <=> ( ( v4672(VarCurr,bitIndex2)
        <=> $false )
        & ( v4672(VarCurr,bitIndex1)
        <=> $false )
        & ( v4672(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_111,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6504(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v6501(VarNext,B)
            <=> v6501(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_120,axiom,
    ! [VarNext] :
      ( v6504(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v6501(VarNext,B)
          <=> v6520(VarNext,B) ) ) ) ).

fof(addAssignment_1677,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v6520(VarNext,B)
          <=> v6518(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_166,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6518(VarCurr,B)
          <=> v6302(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_168,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6518(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1166,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6504(VarNext)
      <=> ( v6505(VarNext)
          & v6512(VarNext) ) ) ) ).

fof(addAssignment_1676,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6512(VarNext)
      <=> v6510(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1165,axiom,
    ! [VarCurr] :
      ( v6510(VarCurr)
    <=> ( v6513(VarCurr)
        | v5397(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1164,axiom,
    ! [VarCurr] :
      ( v6513(VarCurr)
    <=> ( v6514(VarCurr)
        & v4666(VarCurr) ) ) ).

fof(addAssignmentInitValueVector_28,axiom,
    ( v4666(constB0)
  <=> $false ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1163,axiom,
    ! [VarCurr] :
      ( v6514(VarCurr)
    <=> ( v6289(VarCurr)
        & v6515(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1162,axiom,
    ! [VarCurr] :
      ( v6515(VarCurr)
    <=> ( v6516(VarCurr)
        | v6517(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_405,axiom,
    ! [VarCurr] :
      ( v6517(VarCurr)
    <=> ( ( v4672(VarCurr,bitIndex2)
        <=> $false )
        & ( v4672(VarCurr,bitIndex1)
        <=> $true )
        & ( v4672(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_404,axiom,
    ! [VarCurr] :
      ( v6516(VarCurr)
    <=> ( ( v4672(VarCurr,bitIndex2)
        <=> $false )
        & ( v4672(VarCurr,bitIndex1)
        <=> $false )
        & ( v4672(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1161,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6505(VarNext)
      <=> ( v6507(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_547,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6507(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValueVector_27,axiom,
    ! [B] :
      ( range_4_0(B)
     => ( v6501(constB0,B)
      <=> $false ) ) ).

fof(addCaseBooleanConditionEqualRanges1_110,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6486(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v6302(VarNext,B)
            <=> v6302(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_119,axiom,
    ! [VarNext] :
      ( v6486(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v6302(VarNext,B)
          <=> v6497(VarNext,B) ) ) ) ).

fof(addAssignment_1675,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v6497(VarNext,B)
          <=> v6495(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_165,axiom,
    ! [VarCurr] :
      ( ~ v4686(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6495(VarCurr,B)
          <=> v6304(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_167,axiom,
    ! [VarCurr] :
      ( v4686(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6495(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1160,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6486(VarNext)
      <=> ( v6487(VarNext)
          & v6494(VarNext) ) ) ) ).

fof(addAssignment_1674,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6494(VarNext)
      <=> v6492(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1159,axiom,
    ! [VarCurr] :
      ( v6492(VarCurr)
    <=> ( v67(VarCurr)
        | v4686(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1158,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6487(VarNext)
      <=> ( v6489(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_546,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6489(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValueVector_26,axiom,
    ! [B] :
      ( range_4_0(B)
     => ( v6302(constB0,B)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_60,axiom,
    ! [VarCurr] :
      ( ( ~ v6482(VarCurr)
        & ~ v6483(VarCurr) )
     => ! [B] :
          ( range_4_0(B)
         => ( v6304(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_142,axiom,
    ! [VarCurr] :
      ( v6483(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6304(VarCurr,B)
          <=> v6306(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_134,axiom,
    ! [VarCurr] :
      ( v6482(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6304(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1157,axiom,
    ! [VarCurr] :
      ( v6483(VarCurr)
    <=> ( v4902(VarCurr)
        | v4905(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1156,axiom,
    ! [VarCurr] :
      ( v6482(VarCurr)
    <=> ( v4899(VarCurr)
        | v4900(VarCurr) ) ) ).

fof(addAssignment_1673,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6306(VarCurr,B)
      <=> v6308(VarCurr,B) ) ) ).

fof(addAssignment_1672,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6308(VarCurr,B)
      <=> v6310(VarCurr,B) ) ) ).

fof(addAssignment_1671,axiom,
    ! [VarCurr] :
      ( ( v6310(VarCurr,bitIndex4)
      <=> v6312(VarCurr,bitIndex19) )
      & ( v6310(VarCurr,bitIndex3)
      <=> v6312(VarCurr,bitIndex18) )
      & ( v6310(VarCurr,bitIndex2)
      <=> v6312(VarCurr,bitIndex17) )
      & ( v6310(VarCurr,bitIndex1)
      <=> v6312(VarCurr,bitIndex16) )
      & ( v6310(VarCurr,bitIndex0)
      <=> v6312(VarCurr,bitIndex15) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_109,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6451(VarNext)
       => ! [B] :
            ( range_19_15(B)
           => ( v6312(VarNext,B)
            <=> v6312(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionShiftedRanges0_6,axiom,
    ! [VarNext] :
      ( v6451(VarNext)
     => ( ( v6312(VarNext,bitIndex19)
        <=> v6477(VarNext,bitIndex4) )
        & ( v6312(VarNext,bitIndex18)
        <=> v6477(VarNext,bitIndex3) )
        & ( v6312(VarNext,bitIndex17)
        <=> v6477(VarNext,bitIndex2) )
        & ( v6312(VarNext,bitIndex16)
        <=> v6477(VarNext,bitIndex1) )
        & ( v6312(VarNext,bitIndex15)
        <=> v6477(VarNext,bitIndex0) ) ) ) ).

fof(addAssignment_1670,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v6477(VarNext,B)
          <=> v6475(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_141,axiom,
    ! [VarCurr] :
      ( ~ v6414(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6475(VarCurr,B)
          <=> v6478(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_133,axiom,
    ! [VarCurr] :
      ( v6414(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6475(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_59,axiom,
    ! [VarCurr] :
      ( ( ~ v6464(VarCurr)
        & ~ v6466(VarCurr) )
     => ! [B] :
          ( range_4_0(B)
         => ( v6478(VarCurr,B)
          <=> v6443(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_140,axiom,
    ! [VarCurr] :
      ( v6466(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6478(VarCurr,B)
          <=> v6436(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0_7,axiom,
    ! [VarCurr] :
      ( v6464(VarCurr)
     => ( ( v6478(VarCurr,bitIndex4)
        <=> v6312(VarCurr,bitIndex14) )
        & ( v6478(VarCurr,bitIndex3)
        <=> v6312(VarCurr,bitIndex13) )
        & ( v6478(VarCurr,bitIndex2)
        <=> v6312(VarCurr,bitIndex12) )
        & ( v6478(VarCurr,bitIndex1)
        <=> v6312(VarCurr,bitIndex11) )
        & ( v6478(VarCurr,bitIndex0)
        <=> v6312(VarCurr,bitIndex10) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1155,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6451(VarNext)
      <=> ( v6452(VarNext)
          & v6459(VarNext) ) ) ) ).

fof(addAssignment_1669,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6459(VarNext)
      <=> v6457(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1154,axiom,
    ! [VarCurr] :
      ( v6457(VarCurr)
    <=> ( v6460(VarCurr)
        & v6471(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1153,axiom,
    ! [VarCurr] :
      ( v6471(VarCurr)
    <=> ( v6472(VarCurr)
        | v6414(VarCurr) ) ) ).

fof(writeUnaryOperator_545,axiom,
    ! [VarCurr] :
      ( ~ v6472(VarCurr)
    <=> v6473(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_403,axiom,
    ! [VarCurr] :
      ( v6473(VarCurr)
    <=> ( ( v6474(VarCurr,bitIndex1)
        <=> $false )
        & ( v6474(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1668,axiom,
    ! [VarCurr] :
      ( v6474(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_1667,axiom,
    ! [VarCurr] :
      ( v6474(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1152,axiom,
    ! [VarCurr] :
      ( v6460(VarCurr)
    <=> ( v6414(VarCurr)
        | v6461(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1151,axiom,
    ! [VarCurr] :
      ( v6461(VarCurr)
    <=> ( v6462(VarCurr)
        & v6470(VarCurr) ) ) ).

fof(writeUnaryOperator_544,axiom,
    ! [VarCurr] :
      ( ~ v6470(VarCurr)
    <=> v6414(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1150,axiom,
    ! [VarCurr] :
      ( v6462(VarCurr)
    <=> ( v6463(VarCurr)
        | v6468(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_402,axiom,
    ! [VarCurr] :
      ( v6468(VarCurr)
    <=> ( ( v6469(VarCurr,bitIndex1)
        <=> $true )
        & ( v6469(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1666,axiom,
    ! [VarCurr] :
      ( v6469(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_1665,axiom,
    ! [VarCurr] :
      ( v6469(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1149,axiom,
    ! [VarCurr] :
      ( v6463(VarCurr)
    <=> ( v6464(VarCurr)
        | v6466(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_401,axiom,
    ! [VarCurr] :
      ( v6466(VarCurr)
    <=> ( ( v6467(VarCurr,bitIndex1)
        <=> $true )
        & ( v6467(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1664,axiom,
    ! [VarCurr] :
      ( v6467(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_1663,axiom,
    ! [VarCurr] :
      ( v6467(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_400,axiom,
    ! [VarCurr] :
      ( v6464(VarCurr)
    <=> ( ( v6465(VarCurr,bitIndex1)
        <=> $false )
        & ( v6465(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1662,axiom,
    ! [VarCurr] :
      ( v6465(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_1661,axiom,
    ! [VarCurr] :
      ( v6465(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1148,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6452(VarNext)
      <=> ( v6454(VarNext)
          & v2503(VarNext) ) ) ) ).

fof(writeUnaryOperator_543,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6454(VarNext)
      <=> v2510(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_164,axiom,
    ! [VarCurr] :
      ( ~ v6445(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6443(VarCurr,B)
          <=> v6447(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_166,axiom,
    ! [VarCurr] :
      ( v6445(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6443(VarCurr,B)
          <=> v6365(VarCurr,B) ) ) ) ).

fof(addAssignment_1660,axiom,
    ! [VarCurr] :
      ( ( v6447(VarCurr,bitIndex4)
      <=> v6312(VarCurr,bitIndex14) )
      & ( v6447(VarCurr,bitIndex3)
      <=> v6312(VarCurr,bitIndex13) )
      & ( v6447(VarCurr,bitIndex2)
      <=> v6312(VarCurr,bitIndex12) )
      & ( v6447(VarCurr,bitIndex1)
      <=> v6312(VarCurr,bitIndex11) )
      & ( v6447(VarCurr,bitIndex0)
      <=> v6312(VarCurr,bitIndex10) ) ) ).

fof(addAssignment_1659,axiom,
    ! [VarCurr] :
      ( v6445(VarCurr)
    <=> v6318(VarCurr,bitIndex1) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_163,axiom,
    ! [VarCurr] :
      ( ~ v6438(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6436(VarCurr,B)
          <=> v6440(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_165,axiom,
    ! [VarCurr] :
      ( v6438(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6436(VarCurr,B)
          <=> v6365(VarCurr,B) ) ) ) ).

fof(addAssignment_1658,axiom,
    ! [VarCurr] :
      ( ( v6440(VarCurr,bitIndex4)
      <=> v6312(VarCurr,bitIndex19) )
      & ( v6440(VarCurr,bitIndex3)
      <=> v6312(VarCurr,bitIndex18) )
      & ( v6440(VarCurr,bitIndex2)
      <=> v6312(VarCurr,bitIndex17) )
      & ( v6440(VarCurr,bitIndex1)
      <=> v6312(VarCurr,bitIndex16) )
      & ( v6440(VarCurr,bitIndex0)
      <=> v6312(VarCurr,bitIndex15) ) ) ).

fof(addAssignment_1657,axiom,
    ! [VarCurr] :
      ( v6438(VarCurr)
    <=> v6318(VarCurr,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_108,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6404(VarNext)
       => ! [B] :
            ( range_14_10(B)
           => ( v6312(VarNext,B)
            <=> v6312(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionShiftedRanges0_5,axiom,
    ! [VarNext] :
      ( v6404(VarNext)
     => ( ( v6312(VarNext,bitIndex14)
        <=> v6431(VarNext,bitIndex4) )
        & ( v6312(VarNext,bitIndex13)
        <=> v6431(VarNext,bitIndex3) )
        & ( v6312(VarNext,bitIndex12)
        <=> v6431(VarNext,bitIndex2) )
        & ( v6312(VarNext,bitIndex11)
        <=> v6431(VarNext,bitIndex1) )
        & ( v6312(VarNext,bitIndex10)
        <=> v6431(VarNext,bitIndex0) ) ) ) ).

fof(addAssignment_1656,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v6431(VarNext,B)
          <=> v6429(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_139,axiom,
    ! [VarCurr] :
      ( ~ v6414(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6429(VarCurr,B)
          <=> v6432(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_132,axiom,
    ! [VarCurr] :
      ( v6414(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6429(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_58,axiom,
    ! [VarCurr] :
      ( ( ~ v6418(VarCurr)
        & ~ v6420(VarCurr) )
     => ! [B] :
          ( range_4_0(B)
         => ( v6432(VarCurr,B)
          <=> v6396(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_138,axiom,
    ! [VarCurr] :
      ( v6420(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6432(VarCurr,B)
          <=> v6314(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0_6,axiom,
    ! [VarCurr] :
      ( v6418(VarCurr)
     => ( ( v6432(VarCurr,bitIndex4)
        <=> v6312(VarCurr,bitIndex9) )
        & ( v6432(VarCurr,bitIndex3)
        <=> v6312(VarCurr,bitIndex8) )
        & ( v6432(VarCurr,bitIndex2)
        <=> v6312(VarCurr,bitIndex7) )
        & ( v6432(VarCurr,bitIndex1)
        <=> v6312(VarCurr,bitIndex6) )
        & ( v6432(VarCurr,bitIndex0)
        <=> v6312(VarCurr,bitIndex5) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1147,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6404(VarNext)
      <=> ( v6405(VarNext)
          & v6412(VarNext) ) ) ) ).

fof(addAssignment_1655,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6412(VarNext)
      <=> v6410(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1146,axiom,
    ! [VarCurr] :
      ( v6410(VarCurr)
    <=> ( v6413(VarCurr)
        & v6425(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1145,axiom,
    ! [VarCurr] :
      ( v6425(VarCurr)
    <=> ( v6426(VarCurr)
        | v6414(VarCurr) ) ) ).

fof(writeUnaryOperator_542,axiom,
    ! [VarCurr] :
      ( ~ v6426(VarCurr)
    <=> v6427(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_399,axiom,
    ! [VarCurr] :
      ( v6427(VarCurr)
    <=> ( ( v6428(VarCurr,bitIndex1)
        <=> $false )
        & ( v6428(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1654,axiom,
    ! [VarCurr] :
      ( v6428(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_1653,axiom,
    ! [VarCurr] :
      ( v6428(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1144,axiom,
    ! [VarCurr] :
      ( v6413(VarCurr)
    <=> ( v6414(VarCurr)
        | v6415(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1143,axiom,
    ! [VarCurr] :
      ( v6415(VarCurr)
    <=> ( v6416(VarCurr)
        & v6424(VarCurr) ) ) ).

fof(writeUnaryOperator_541,axiom,
    ! [VarCurr] :
      ( ~ v6424(VarCurr)
    <=> v6414(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1142,axiom,
    ! [VarCurr] :
      ( v6416(VarCurr)
    <=> ( v6417(VarCurr)
        | v6422(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_398,axiom,
    ! [VarCurr] :
      ( v6422(VarCurr)
    <=> ( ( v6423(VarCurr,bitIndex1)
        <=> $true )
        & ( v6423(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1652,axiom,
    ! [VarCurr] :
      ( v6423(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_1651,axiom,
    ! [VarCurr] :
      ( v6423(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1141,axiom,
    ! [VarCurr] :
      ( v6417(VarCurr)
    <=> ( v6418(VarCurr)
        | v6420(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_397,axiom,
    ! [VarCurr] :
      ( v6420(VarCurr)
    <=> ( ( v6421(VarCurr,bitIndex1)
        <=> $true )
        & ( v6421(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1650,axiom,
    ! [VarCurr] :
      ( v6421(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_1649,axiom,
    ! [VarCurr] :
      ( v6421(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_396,axiom,
    ! [VarCurr] :
      ( v6418(VarCurr)
    <=> ( ( v6419(VarCurr,bitIndex1)
        <=> $false )
        & ( v6419(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1648,axiom,
    ! [VarCurr] :
      ( v6419(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_1647,axiom,
    ! [VarCurr] :
      ( v6419(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(writeUnaryOperator_540,axiom,
    ! [VarCurr] :
      ( ~ v6414(VarCurr)
    <=> v2473(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1140,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6405(VarNext)
      <=> ( v6406(VarNext)
          & v2503(VarNext) ) ) ) ).

fof(writeUnaryOperator_539,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6406(VarNext)
      <=> v2510(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_162,axiom,
    ! [VarCurr] :
      ( ~ v6398(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6396(VarCurr,B)
          <=> v6400(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_164,axiom,
    ! [VarCurr] :
      ( v6398(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6396(VarCurr,B)
          <=> v6365(VarCurr,B) ) ) ) ).

fof(addAssignment_1646,axiom,
    ! [VarCurr] :
      ( ( v6400(VarCurr,bitIndex4)
      <=> v6312(VarCurr,bitIndex9) )
      & ( v6400(VarCurr,bitIndex3)
      <=> v6312(VarCurr,bitIndex8) )
      & ( v6400(VarCurr,bitIndex2)
      <=> v6312(VarCurr,bitIndex7) )
      & ( v6400(VarCurr,bitIndex1)
      <=> v6312(VarCurr,bitIndex6) )
      & ( v6400(VarCurr,bitIndex0)
      <=> v6312(VarCurr,bitIndex5) ) ) ).

fof(addAssignment_1645,axiom,
    ! [VarCurr] :
      ( v6398(VarCurr)
    <=> v6318(VarCurr,bitIndex2) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_161,axiom,
    ! [VarCurr] :
      ( ~ v6316(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6314(VarCurr,B)
          <=> v6393(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_163,axiom,
    ! [VarCurr] :
      ( v6316(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6314(VarCurr,B)
          <=> v6365(VarCurr,B) ) ) ) ).

fof(addAssignment_1644,axiom,
    ! [VarCurr] :
      ( ( v6393(VarCurr,bitIndex4)
      <=> v6312(VarCurr,bitIndex14) )
      & ( v6393(VarCurr,bitIndex3)
      <=> v6312(VarCurr,bitIndex13) )
      & ( v6393(VarCurr,bitIndex2)
      <=> v6312(VarCurr,bitIndex12) )
      & ( v6393(VarCurr,bitIndex1)
      <=> v6312(VarCurr,bitIndex11) )
      & ( v6393(VarCurr,bitIndex0)
      <=> v6312(VarCurr,bitIndex10) ) ) ).

fof(addAssignmentInitValueVector_25,axiom,
    ( ( v6312(constB0,bitIndex19)
    <=> $false )
    & ( v6312(constB0,bitIndex18)
    <=> $false )
    & ( v6312(constB0,bitIndex17)
    <=> $false )
    & ( v6312(constB0,bitIndex16)
    <=> $false )
    & ( v6312(constB0,bitIndex15)
    <=> $false ) ) ).

fof(addAssignment_1643,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6365(VarCurr,B)
      <=> v6367(VarCurr,B) ) ) ).

fof(addAssignment_1642,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6367(VarCurr,B)
      <=> v3269(VarCurr,B) ) ) ).

fof(addAssignment_1641,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v3269(VarCurr,B)
      <=> v3271(VarCurr,B) ) ) ).

fof(addAssignment_1640,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v3271(VarCurr,B)
      <=> v3273(VarCurr,B) ) ) ).

fof(addAssignment_1639,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v3273(VarCurr,B)
      <=> v3275(VarCurr,B) ) ) ).

fof(addAssignment_1638,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v3275(VarCurr,B)
      <=> v3277(VarCurr,B) ) ) ).

fof(addAssignment_1637,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v3277(VarCurr,B)
      <=> v3279(VarCurr,B) ) ) ).

fof(addAssignment_1636,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v3279(VarCurr,B)
      <=> v3281(VarCurr,B) ) ) ).

fof(addAssignment_1635,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v3281(VarCurr,B)
      <=> v4121(VarCurr,B) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_107,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6376(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v4138(VarNext,B)
            <=> v4138(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_118,axiom,
    ! [VarNext] :
      ( v6376(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v4138(VarNext,B)
          <=> v6389(VarNext,B) ) ) ) ).

fof(addAssignment_1634,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v6389(VarNext,B)
          <=> v6387(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_137,axiom,
    ! [VarCurr] :
      ( ~ v4799(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6387(VarCurr,B)
          <=> v6369(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_131,axiom,
    ! [VarCurr] :
      ( v4799(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6387(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1139,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6376(VarNext)
      <=> ( v6377(VarNext)
          & v6384(VarNext) ) ) ) ).

fof(addAssignment_1633,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6384(VarNext)
      <=> v6382(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1138,axiom,
    ! [VarCurr] :
      ( v6382(VarCurr)
    <=> ( v4799(VarCurr)
        | v6385(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1137,axiom,
    ! [VarCurr] :
      ( v6385(VarCurr)
    <=> ( v4801(VarCurr)
        & v6386(VarCurr) ) ) ).

fof(writeUnaryOperator_538,axiom,
    ! [VarCurr] :
      ( ~ v6386(VarCurr)
    <=> v4799(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1136,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6377(VarNext)
      <=> ( v6379(VarNext)
          & v4099(VarNext) ) ) ) ).

fof(writeUnaryOperator_537,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6379(VarNext)
      <=> v4106(VarNext) ) ) ).

fof(addAssignment_1632,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6369(VarCurr,B)
      <=> v6371(VarCurr,B) ) ) ).

fof(addAssignment_1631,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6371(VarCurr,B)
      <=> v6373(VarCurr,B) ) ) ).

fof(addAssignment_1630,axiom,
    ! [VarCurr] :
      ( ( v6373(VarCurr,bitIndex4)
      <=> v4779(VarCurr,bitIndex35) )
      & ( v6373(VarCurr,bitIndex3)
      <=> v4779(VarCurr,bitIndex34) )
      & ( v6373(VarCurr,bitIndex2)
      <=> v4779(VarCurr,bitIndex33) )
      & ( v6373(VarCurr,bitIndex1)
      <=> v4779(VarCurr,bitIndex32) )
      & ( v6373(VarCurr,bitIndex0)
      <=> v4779(VarCurr,bitIndex31) ) ) ).

fof(addAssignment_1629,axiom,
    ! [VarCurr,B] :
      ( range_35_31(B)
     => ( v4779(VarCurr,B)
      <=> v4781(VarCurr,B) ) ) ).

fof(addAssignment_1628,axiom,
    ! [VarCurr,B] :
      ( range_35_31(B)
     => ( v4781(VarCurr,B)
      <=> v4783(VarCurr,B) ) ) ).

fof(addAssignment_1627,axiom,
    ! [VarCurr,B] :
      ( range_35_31(B)
     => ( v4783(VarCurr,B)
      <=> v4785(VarCurr,B) ) ) ).

fof(addAssignment_1626,axiom,
    ! [VarCurr,B] :
      ( range_35_31(B)
     => ( v4785(VarCurr,B)
      <=> v4787(VarCurr,B) ) ) ).

fof(range_axiom_40,axiom,
    ! [B] :
      ( range_35_31(B)
    <=> ( $false
        | bitIndex31 = B
        | bitIndex32 = B
        | bitIndex33 = B
        | bitIndex34 = B
        | bitIndex35 = B ) ) ).

fof(addAssignment_1625,axiom,
    ! [VarCurr] :
      ( v6316(VarCurr)
    <=> v6318(VarCurr,bitIndex2) ) ).

fof(addAssignment_1624,axiom,
    ! [VarCurr] :
      ( v6318(VarCurr,bitIndex2)
    <=> v6332(VarCurr,bitIndex2) ) ).

fof(addAssignment_1623,axiom,
    ! [VarNext] :
      ( v2539(VarNext,bitIndex1)
    <=> v6357(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_106,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6358(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v6357(VarNext,B)
            <=> v2539(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_117,axiom,
    ! [VarNext] :
      ( v6358(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v6357(VarNext,B)
          <=> v6329(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1135,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6358(VarNext)
      <=> v6359(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1134,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6359(VarNext)
      <=> ( v6361(VarNext)
          & v2503(VarNext) ) ) ) ).

fof(writeUnaryOperator_536,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6361(VarNext)
      <=> v2510(VarNext) ) ) ).

fof(addAssignment_1622,axiom,
    ! [VarCurr] :
      ( v6318(VarCurr,bitIndex1)
    <=> v6332(VarCurr,bitIndex1) ) ).

fof(addAssignment_1621,axiom,
    ! [VarNext] :
      ( v2539(VarNext,bitIndex0)
    <=> v6349(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_105,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6350(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v6349(VarNext,B)
            <=> v2539(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_116,axiom,
    ! [VarNext] :
      ( v6350(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v6349(VarNext,B)
          <=> v6329(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1133,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6350(VarNext)
      <=> v6351(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1132,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6351(VarNext)
      <=> ( v6353(VarNext)
          & v2503(VarNext) ) ) ) ).

fof(writeUnaryOperator_535,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6353(VarNext)
      <=> v2510(VarNext) ) ) ).

fof(addAssignment_1620,axiom,
    ! [VarCurr] :
      ( v6318(VarCurr,bitIndex0)
    <=> v6332(VarCurr,bitIndex0) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_160,axiom,
    ! [VarCurr] :
      ( ~ v6333(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v6332(VarCurr,B)
          <=> v6335(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_162,axiom,
    ! [VarCurr] :
      ( v6333(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v6332(VarCurr,B)
          <=> v6334(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_27,axiom,
    ! [VarCurr] :
      ( ( ~ v6336(VarCurr)
        & ~ v6338(VarCurr)
        & ~ v6342(VarCurr) )
     => ! [B] :
          ( range_6_0(B)
         => ( v6335(VarCurr,B)
          <=> v2539(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_57,axiom,
    ! [VarCurr] :
      ( v6342(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v6335(VarCurr,B)
          <=> v6344(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_136,axiom,
    ! [VarCurr] :
      ( v6338(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v6335(VarCurr,B)
          <=> v6340(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_130,axiom,
    ! [VarCurr] :
      ( v6336(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v6335(VarCurr,B)
          <=> v2539(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_395,axiom,
    ! [VarCurr] :
      ( v6346(VarCurr)
    <=> ( ( v6347(VarCurr,bitIndex1)
        <=> $true )
        & ( v6347(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1619,axiom,
    ! [VarCurr] :
      ( v6347(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_1618,axiom,
    ! [VarCurr] :
      ( v6347(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(addAssignment_1617,axiom,
    ! [VarCurr] :
      ( v6344(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_1616,axiom,
    ! [VarCurr] :
      ( ( v6344(VarCurr,bitIndex6)
      <=> v2539(VarCurr,bitIndex5) )
      & ( v6344(VarCurr,bitIndex5)
      <=> v2539(VarCurr,bitIndex4) )
      & ( v6344(VarCurr,bitIndex4)
      <=> v2539(VarCurr,bitIndex3) )
      & ( v6344(VarCurr,bitIndex3)
      <=> v2539(VarCurr,bitIndex2) )
      & ( v6344(VarCurr,bitIndex2)
      <=> v2539(VarCurr,bitIndex1) )
      & ( v6344(VarCurr,bitIndex1)
      <=> v2539(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_394,axiom,
    ! [VarCurr] :
      ( v6342(VarCurr)
    <=> ( ( v6343(VarCurr,bitIndex1)
        <=> $true )
        & ( v6343(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1615,axiom,
    ! [VarCurr] :
      ( v6343(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_1614,axiom,
    ! [VarCurr] :
      ( v6343(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(addAssignment_1613,axiom,
    ! [VarCurr] :
      ( ( v6340(VarCurr,bitIndex5)
      <=> v2539(VarCurr,bitIndex6) )
      & ( v6340(VarCurr,bitIndex4)
      <=> v2539(VarCurr,bitIndex5) )
      & ( v6340(VarCurr,bitIndex3)
      <=> v2539(VarCurr,bitIndex4) )
      & ( v6340(VarCurr,bitIndex2)
      <=> v2539(VarCurr,bitIndex3) )
      & ( v6340(VarCurr,bitIndex1)
      <=> v2539(VarCurr,bitIndex2) )
      & ( v6340(VarCurr,bitIndex0)
      <=> v2539(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1612,axiom,
    ! [VarCurr] :
      ( v6340(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_393,axiom,
    ! [VarCurr] :
      ( v6338(VarCurr)
    <=> ( ( v6339(VarCurr,bitIndex1)
        <=> $false )
        & ( v6339(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1611,axiom,
    ! [VarCurr] :
      ( v6339(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_1610,axiom,
    ! [VarCurr] :
      ( v6339(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_392,axiom,
    ! [VarCurr] :
      ( v6336(VarCurr)
    <=> ( ( v6337(VarCurr,bitIndex1)
        <=> $false )
        & ( v6337(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1609,axiom,
    ! [VarCurr] :
      ( v6337(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_1608,axiom,
    ! [VarCurr] :
      ( v6337(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(addAssignment_1607,axiom,
    ! [VarCurr] :
      ( v6334(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_1606,axiom,
    ! [VarCurr,B] :
      ( range_6_1(B)
     => ( v6334(VarCurr,B)
      <=> v2537(VarCurr,B) ) ) ).

fof(writeUnaryOperator_534,axiom,
    ! [VarCurr] :
      ( ~ v6333(VarCurr)
    <=> v2473(VarCurr) ) ).

fof(addAssignment_1605,axiom,
    ! [VarCurr] :
      ( v2537(VarCurr,bitIndex1)
    <=> v2538(VarCurr,bitIndex1) ) ).

fof(addAssignment_1604,axiom,
    ! [VarCurr] :
      ( v2537(VarCurr,bitIndex2)
    <=> v2538(VarCurr,bitIndex2) ) ).

fof(addAssignment_1603,axiom,
    ! [VarNext] :
      ( v2539(VarNext,bitIndex2)
    <=> v6320(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_104,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6321(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v6320(VarNext,B)
            <=> v2539(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_115,axiom,
    ! [VarNext] :
      ( v6321(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v6320(VarNext,B)
          <=> v6329(VarNext,B) ) ) ) ).

fof(addAssignment_1602,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v6329(VarNext,B)
          <=> v6327(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_159,axiom,
    ! [VarCurr] :
      ( ~ v2517(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v6327(VarCurr,B)
          <=> v6318(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_161,axiom,
    ! [VarCurr] :
      ( v2517(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v6327(VarCurr,B)
          <=> b0000001(B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1131,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6321(VarNext)
      <=> v6322(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1130,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6322(VarNext)
      <=> ( v6324(VarNext)
          & v2503(VarNext) ) ) ) ).

fof(writeUnaryOperator_533,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6324(VarNext)
      <=> v2510(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges5_2,axiom,
    ! [VarCurr] :
      ( ( ~ v5338(VarCurr)
        & ~ v5339(VarCurr)
        & ~ v5340(VarCurr)
        & ~ v5341(VarCurr)
        & ~ v5353(VarCurr) )
     => ( v6289(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges4_3,axiom,
    ! [VarCurr] :
      ( v5353(VarCurr)
     => ( v6289(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_26,axiom,
    ! [VarCurr] :
      ( v5341(VarCurr)
     => ( v6289(VarCurr)
      <=> v6294(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_56,axiom,
    ! [VarCurr] :
      ( v5340(VarCurr)
     => ( v6289(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_135,axiom,
    ! [VarCurr] :
      ( v5339(VarCurr)
     => ( v6289(VarCurr)
      <=> v6291(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_129,axiom,
    ! [VarCurr] :
      ( v5338(VarCurr)
     => ( v6289(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_134,axiom,
    ! [VarCurr] :
      ( ~ v5343(VarCurr)
     => ( v6294(VarCurr)
      <=> v6295(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_128,axiom,
    ! [VarCurr] :
      ( v5343(VarCurr)
     => ( v6294(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_133,axiom,
    ! [VarCurr] :
      ( ~ v6296(VarCurr)
     => ( v6295(VarCurr)
      <=> v6298(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_127,axiom,
    ! [VarCurr] :
      ( v6296(VarCurr)
     => ( v6295(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_132,axiom,
    ! [VarCurr] :
      ( ~ v6299(VarCurr)
     => ( v6298(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_126,axiom,
    ! [VarCurr] :
      ( v6299(VarCurr)
     => ( v6298(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_391,axiom,
    ! [VarCurr] :
      ( v6300(VarCurr)
    <=> ( v3190(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_390,axiom,
    ! [VarCurr] :
      ( v6299(VarCurr)
    <=> ( v3190(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_389,axiom,
    ! [VarCurr] :
      ( v6297(VarCurr)
    <=> ( v5280(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_388,axiom,
    ! [VarCurr] :
      ( v6296(VarCurr)
    <=> ( v5280(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_131,axiom,
    ! [VarCurr] :
      ( ~ v6292(VarCurr)
     => ( v6291(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_125,axiom,
    ! [VarCurr] :
      ( v6292(VarCurr)
     => ( v6291(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_387,axiom,
    ! [VarCurr] :
      ( v6293(VarCurr)
    <=> ( v3182(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_386,axiom,
    ! [VarCurr] :
      ( v6292(VarCurr)
    <=> ( v3182(VarCurr)
      <=> $true ) ) ).

fof(addAssignment_1601,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6241(VarCurr,B)
      <=> v6243(VarCurr,B) ) ) ).

fof(addAssignment_1600,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6243(VarCurr,B)
      <=> v6245(VarCurr,B) ) ) ).

fof(addAssignment_1599,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6245(VarCurr,B)
      <=> v6247(VarCurr,B) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_103,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6258(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v6247(VarNext,B)
            <=> v6247(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_114,axiom,
    ! [VarNext] :
      ( v6258(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v6247(VarNext,B)
          <=> v6269(VarNext,B) ) ) ) ).

fof(addAssignment_1598,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v6269(VarNext,B)
          <=> v6267(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_158,axiom,
    ! [VarCurr] :
      ( ~ v5250(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6267(VarCurr,B)
          <=> v6249(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_160,axiom,
    ! [VarCurr] :
      ( v5250(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v6267(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1129,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6258(VarNext)
      <=> ( v6259(VarNext)
          & v6266(VarNext) ) ) ) ).

fof(addAssignment_1597,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6266(VarNext)
      <=> v6264(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1128,axiom,
    ! [VarCurr] :
      ( v6264(VarCurr)
    <=> ( v5018(VarCurr)
        | v5250(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1127,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6259(VarNext)
      <=> ( v6261(VarNext)
          & v4988(VarNext) ) ) ) ).

fof(writeUnaryOperator_532,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6261(VarNext)
      <=> v4995(VarNext) ) ) ).

fof(addAssignmentInitValueVector_24,axiom,
    ! [B] :
      ( range_4_0(B)
     => ( v6247(constB0,B)
      <=> $false ) ) ).

fof(addAssignment_1596,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6249(VarCurr,B)
      <=> v6251(VarCurr,B) ) ) ).

fof(addAssignment_1595,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6251(VarCurr,B)
      <=> v6253(VarCurr,B) ) ) ).

fof(addAssignment_1594,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6253(VarCurr,B)
      <=> v6255(VarCurr,B) ) ) ).

fof(addAssignment_1593,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v6255(VarCurr,B)
      <=> v5042(VarCurr,B) ) ) ).

fof(addAssignment_1592,axiom,
    ! [VarCurr,B] :
      ( range_43_0(B)
     => ( v5627(VarCurr,B)
      <=> v5629(VarCurr,B) ) ) ).

fof(addAssignment_1591,axiom,
    ! [VarCurr,B] :
      ( range_43_0(B)
     => ( v5629(VarCurr,B)
      <=> v5631(VarCurr,B) ) ) ).

fof(addAssignment_1590,axiom,
    ! [VarCurr,B] :
      ( range_43_0(B)
     => ( v5631(VarCurr,B)
      <=> v5633(VarCurr,B) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_102,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6226(VarNext)
       => ! [B] :
            ( range_43_0(B)
           => ( v5633(VarNext,B)
            <=> v5633(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_113,axiom,
    ! [VarNext] :
      ( v6226(VarNext)
     => ! [B] :
          ( range_43_0(B)
         => ( v5633(VarNext,B)
          <=> v6234(VarNext,B) ) ) ) ).

fof(addAssignment_1589,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_43_0(B)
         => ( v6234(VarNext,B)
          <=> v6232(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_157,axiom,
    ! [VarCurr] :
      ( ~ v5250(VarCurr)
     => ! [B] :
          ( range_43_0(B)
         => ( v6232(VarCurr,B)
          <=> v6235(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_159,axiom,
    ! [VarCurr] :
      ( v5250(VarCurr)
     => ! [B] :
          ( range_43_0(B)
         => ( v6232(VarCurr,B)
          <=> $false ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_156,axiom,
    ! [VarCurr] :
      ( ~ v6236(VarCurr)
     => ! [B] :
          ( range_43_0(B)
         => ( v6235(VarCurr,B)
          <=> $false ) ) ) ).

fof(bitBlastConstant_490,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex43) ).

fof(bitBlastConstant_489,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex42) ).

fof(bitBlastConstant_488,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex41) ).

fof(bitBlastConstant_487,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex40) ).

fof(bitBlastConstant_486,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex39) ).

fof(bitBlastConstant_485,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex38) ).

fof(bitBlastConstant_484,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex37) ).

fof(bitBlastConstant_483,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex36) ).

fof(bitBlastConstant_482,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex35) ).

fof(bitBlastConstant_481,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex34) ).

fof(bitBlastConstant_480,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex33) ).

fof(bitBlastConstant_479,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex32) ).

fof(bitBlastConstant_478,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex31) ).

fof(bitBlastConstant_477,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex30) ).

fof(bitBlastConstant_476,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex29) ).

fof(bitBlastConstant_475,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex28) ).

fof(bitBlastConstant_474,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex27) ).

fof(bitBlastConstant_473,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex26) ).

fof(bitBlastConstant_472,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex25) ).

fof(bitBlastConstant_471,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex24) ).

fof(bitBlastConstant_470,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex23) ).

fof(bitBlastConstant_469,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex22) ).

fof(bitBlastConstant_468,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex21) ).

fof(bitBlastConstant_467,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex20) ).

fof(bitBlastConstant_466,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex19) ).

fof(bitBlastConstant_465,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex18) ).

fof(bitBlastConstant_464,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex17) ).

fof(bitBlastConstant_463,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex16) ).

fof(bitBlastConstant_462,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex15) ).

fof(bitBlastConstant_461,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex14) ).

fof(bitBlastConstant_460,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex13) ).

fof(bitBlastConstant_459,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex12) ).

fof(bitBlastConstant_458,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex11) ).

fof(bitBlastConstant_457,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex10) ).

fof(bitBlastConstant_456,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex9) ).

fof(bitBlastConstant_455,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex8) ).

fof(bitBlastConstant_454,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex7) ).

fof(bitBlastConstant_453,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex6) ).

fof(bitBlastConstant_452,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex5) ).

fof(bitBlastConstant_451,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex4) ).

fof(bitBlastConstant_450,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex3) ).

fof(bitBlastConstant_449,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex2) ).

fof(bitBlastConstant_448,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex1) ).

fof(bitBlastConstant_447,axiom,
    ~ b00000000000000000000000000000000000000000000(bitIndex0) ).

fof(addConditionBooleanCondEqualRangesThenBranch_158,axiom,
    ! [VarCurr] :
      ( v6236(VarCurr)
     => ! [B] :
          ( range_43_0(B)
         => ( v6235(VarCurr,B)
          <=> v6237(VarCurr,B) ) ) ) ).

fof(range_axiom_39,axiom,
    ! [B] :
      ( range_43_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B
        | bitIndex11 = B
        | bitIndex12 = B
        | bitIndex13 = B
        | bitIndex14 = B
        | bitIndex15 = B
        | bitIndex16 = B
        | bitIndex17 = B
        | bitIndex18 = B
        | bitIndex19 = B
        | bitIndex20 = B
        | bitIndex21 = B
        | bitIndex22 = B
        | bitIndex23 = B
        | bitIndex24 = B
        | bitIndex25 = B
        | bitIndex26 = B
        | bitIndex27 = B
        | bitIndex28 = B
        | bitIndex29 = B
        | bitIndex30 = B
        | bitIndex31 = B
        | bitIndex32 = B
        | bitIndex33 = B
        | bitIndex34 = B
        | bitIndex35 = B
        | bitIndex36 = B
        | bitIndex37 = B
        | bitIndex38 = B
        | bitIndex39 = B
        | bitIndex40 = B
        | bitIndex41 = B
        | bitIndex42 = B
        | bitIndex43 = B ) ) ).

fof(addAssignment_1588,axiom,
    ! [VarCurr,B] :
      ( range_31_0(B)
     => ( v6237(VarCurr,B)
      <=> v5715(VarCurr,B) ) ) ).

fof(addAssignment_1587,axiom,
    ! [VarCurr] :
      ( v6237(VarCurr,bitIndex32)
    <=> v5671(VarCurr) ) ).

fof(addAssignment_1586,axiom,
    ! [VarCurr] :
      ( ( v6237(VarCurr,bitIndex37)
      <=> v5581(VarCurr,bitIndex4) )
      & ( v6237(VarCurr,bitIndex36)
      <=> v5581(VarCurr,bitIndex3) )
      & ( v6237(VarCurr,bitIndex35)
      <=> v5581(VarCurr,bitIndex2) )
      & ( v6237(VarCurr,bitIndex34)
      <=> v5581(VarCurr,bitIndex1) )
      & ( v6237(VarCurr,bitIndex33)
      <=> v5581(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1585,axiom,
    ! [VarCurr] :
      ( ( v6237(VarCurr,bitIndex43)
      <=> v5635(VarCurr,bitIndex5) )
      & ( v6237(VarCurr,bitIndex42)
      <=> v5635(VarCurr,bitIndex4) )
      & ( v6237(VarCurr,bitIndex41)
      <=> v5635(VarCurr,bitIndex3) )
      & ( v6237(VarCurr,bitIndex40)
      <=> v5635(VarCurr,bitIndex2) )
      & ( v6237(VarCurr,bitIndex39)
      <=> v5635(VarCurr,bitIndex1) )
      & ( v6237(VarCurr,bitIndex38)
      <=> v5635(VarCurr,bitIndex0) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1126,axiom,
    ! [VarCurr] :
      ( v6236(VarCurr)
    <=> ( v5016(VarCurr)
        & v5141(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1125,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6226(VarNext)
      <=> v6227(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1124,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v6227(VarNext)
      <=> ( v6229(VarNext)
          & v4988(VarNext) ) ) ) ).

fof(writeUnaryOperator_531,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v6229(VarNext)
      <=> v4995(VarNext) ) ) ).

fof(addAssignmentInitValue_60,axiom,
    ~ v5633(constB0,bitIndex31) ).

fof(addAssignmentInitValue_59,axiom,
    ~ v5633(constB0,bitIndex30) ).

fof(addAssignmentInitValue_58,axiom,
    ~ v5633(constB0,bitIndex29) ).

fof(addAssignmentInitValue_57,axiom,
    ~ v5633(constB0,bitIndex28) ).

fof(addAssignmentInitValue_56,axiom,
    ~ v5633(constB0,bitIndex27) ).

fof(addAssignmentInitValue_55,axiom,
    ~ v5633(constB0,bitIndex26) ).

fof(addAssignmentInitValue_54,axiom,
    ~ v5633(constB0,bitIndex25) ).

fof(addAssignmentInitValue_53,axiom,
    ~ v5633(constB0,bitIndex24) ).

fof(addAssignmentInitValue_52,axiom,
    ~ v5633(constB0,bitIndex23) ).

fof(addAssignmentInitValue_51,axiom,
    ~ v5633(constB0,bitIndex22) ).

fof(addAssignmentInitValue_50,axiom,
    ~ v5633(constB0,bitIndex21) ).

fof(addAssignmentInitValue_49,axiom,
    ~ v5633(constB0,bitIndex20) ).

fof(addAssignmentInitValue_48,axiom,
    ~ v5633(constB0,bitIndex19) ).

fof(addAssignmentInitValue_47,axiom,
    ~ v5633(constB0,bitIndex18) ).

fof(addAssignmentInitValue_46,axiom,
    ~ v5633(constB0,bitIndex17) ).

fof(addAssignmentInitValue_45,axiom,
    ~ v5633(constB0,bitIndex16) ).

fof(addAssignmentInitValue_44,axiom,
    ~ v5633(constB0,bitIndex15) ).

fof(addAssignmentInitValue_43,axiom,
    ~ v5633(constB0,bitIndex14) ).

fof(addAssignmentInitValue_42,axiom,
    ~ v5633(constB0,bitIndex13) ).

fof(addAssignmentInitValue_41,axiom,
    ~ v5633(constB0,bitIndex12) ).

fof(addAssignmentInitValue_40,axiom,
    ~ v5633(constB0,bitIndex11) ).

fof(addAssignmentInitValue_39,axiom,
    ~ v5633(constB0,bitIndex10) ).

fof(addAssignmentInitValue_38,axiom,
    ~ v5633(constB0,bitIndex9) ).

fof(addAssignmentInitValue_37,axiom,
    ~ v5633(constB0,bitIndex8) ).

fof(addAssignmentInitValue_36,axiom,
    ~ v5633(constB0,bitIndex7) ).

fof(addAssignmentInitValue_35,axiom,
    ~ v5633(constB0,bitIndex6) ).

fof(addAssignmentInitValue_34,axiom,
    ~ v5633(constB0,bitIndex5) ).

fof(addAssignmentInitValue_33,axiom,
    ~ v5633(constB0,bitIndex4) ).

fof(addAssignmentInitValue_32,axiom,
    ~ v5633(constB0,bitIndex3) ).

fof(addAssignmentInitValue_31,axiom,
    ~ v5633(constB0,bitIndex2) ).

fof(addAssignmentInitValue_30,axiom,
    ~ v5633(constB0,bitIndex1) ).

fof(addAssignmentInitValue_29,axiom,
    ~ v5633(constB0,bitIndex0) ).

fof(bitBlastConstant_446,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex31) ).

fof(bitBlastConstant_445,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex30) ).

fof(bitBlastConstant_444,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex29) ).

fof(bitBlastConstant_443,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex28) ).

fof(bitBlastConstant_442,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex27) ).

fof(bitBlastConstant_441,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex26) ).

fof(bitBlastConstant_440,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex25) ).

fof(bitBlastConstant_439,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex24) ).

fof(bitBlastConstant_438,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex23) ).

fof(bitBlastConstant_437,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex22) ).

fof(bitBlastConstant_436,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex21) ).

fof(bitBlastConstant_435,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex20) ).

fof(bitBlastConstant_434,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex19) ).

fof(bitBlastConstant_433,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex18) ).

fof(bitBlastConstant_432,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex17) ).

fof(bitBlastConstant_431,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex16) ).

fof(bitBlastConstant_430,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex15) ).

fof(bitBlastConstant_429,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex14) ).

fof(bitBlastConstant_428,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex13) ).

fof(bitBlastConstant_427,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex12) ).

fof(bitBlastConstant_426,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex11) ).

fof(bitBlastConstant_425,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex10) ).

fof(bitBlastConstant_424,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex9) ).

fof(bitBlastConstant_423,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex8) ).

fof(bitBlastConstant_422,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex7) ).

fof(bitBlastConstant_421,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex6) ).

fof(bitBlastConstant_420,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex5) ).

fof(bitBlastConstant_419,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex4) ).

fof(bitBlastConstant_418,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex3) ).

fof(bitBlastConstant_417,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex2) ).

fof(bitBlastConstant_416,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex1) ).

fof(bitBlastConstant_415,axiom,
    ~ bxxxxxxxxxxxx00000000000000000000000000000000(bitIndex0) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_45,axiom,
    ! [VarCurr] :
      ( ~ v6217(VarCurr)
     => ( v5715(VarCurr,bitIndex31)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_43,axiom,
    ! [VarCurr] :
      ( v6217(VarCurr)
     => ( v5715(VarCurr,bitIndex31)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_309,axiom,
    ! [VarCurr] :
      ( v6217(VarCurr)
    <=> ( v6219(VarCurr,bitIndex6)
        | v6220(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_308,axiom,
    ! [VarCurr] :
      ( v6220(VarCurr)
    <=> ( v6219(VarCurr,bitIndex5)
        & v6221(VarCurr) ) ) ).

fof(writeUnaryOperator_530,axiom,
    ! [VarCurr] :
      ( ~ v6221(VarCurr)
    <=> v6219(VarCurr,bitIndex6) ) ).

fof(addAssignment_1584,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6219(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1583,axiom,
    ! [VarCurr] :
      ( v6219(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_44,axiom,
    ! [VarCurr] :
      ( ~ v6204(VarCurr)
     => ( v5715(VarCurr,bitIndex30)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_42,axiom,
    ! [VarCurr] :
      ( v6204(VarCurr)
     => ( v5715(VarCurr,bitIndex30)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_307,axiom,
    ! [VarCurr] :
      ( v6204(VarCurr)
    <=> ( v6206(VarCurr,bitIndex6)
        | v6207(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1123,axiom,
    ! [VarCurr] :
      ( v6207(VarCurr)
    <=> ( v6208(VarCurr)
        & v6215(VarCurr) ) ) ).

fof(writeUnaryOperator_529,axiom,
    ! [VarCurr] :
      ( ~ v6215(VarCurr)
    <=> v6206(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_306,axiom,
    ! [VarCurr] :
      ( v6208(VarCurr)
    <=> ( v6206(VarCurr,bitIndex5)
        | v6209(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1122,axiom,
    ! [VarCurr] :
      ( v6209(VarCurr)
    <=> ( v6210(VarCurr)
        & v6214(VarCurr) ) ) ).

fof(writeUnaryOperator_528,axiom,
    ! [VarCurr] :
      ( ~ v6214(VarCurr)
    <=> v6206(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_305,axiom,
    ! [VarCurr] :
      ( v6210(VarCurr)
    <=> ( v6211(VarCurr)
        & v6206(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorShiftedRanges_304,axiom,
    ! [VarCurr] :
      ( v6211(VarCurr)
    <=> ( v6212(VarCurr)
        & v6206(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_303,axiom,
    ! [VarCurr] :
      ( v6212(VarCurr)
    <=> ( v6213(VarCurr)
        & v6206(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_302,axiom,
    ! [VarCurr] :
      ( v6213(VarCurr)
    <=> ( v6206(VarCurr,bitIndex0)
        & v6206(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1582,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6206(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1581,axiom,
    ! [VarCurr] :
      ( v6206(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_43,axiom,
    ! [VarCurr] :
      ( ~ v6192(VarCurr)
     => ( v5715(VarCurr,bitIndex29)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_41,axiom,
    ! [VarCurr] :
      ( v6192(VarCurr)
     => ( v5715(VarCurr,bitIndex29)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_301,axiom,
    ! [VarCurr] :
      ( v6192(VarCurr)
    <=> ( v6194(VarCurr,bitIndex6)
        | v6195(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1121,axiom,
    ! [VarCurr] :
      ( v6195(VarCurr)
    <=> ( v6196(VarCurr)
        & v6202(VarCurr) ) ) ).

fof(writeUnaryOperator_527,axiom,
    ! [VarCurr] :
      ( ~ v6202(VarCurr)
    <=> v6194(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_300,axiom,
    ! [VarCurr] :
      ( v6196(VarCurr)
    <=> ( v6194(VarCurr,bitIndex5)
        | v6197(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1120,axiom,
    ! [VarCurr] :
      ( v6197(VarCurr)
    <=> ( v6198(VarCurr)
        & v6201(VarCurr) ) ) ).

fof(writeUnaryOperator_526,axiom,
    ! [VarCurr] :
      ( ~ v6201(VarCurr)
    <=> v6194(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_299,axiom,
    ! [VarCurr] :
      ( v6198(VarCurr)
    <=> ( v6199(VarCurr)
        & v6194(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorShiftedRanges_298,axiom,
    ! [VarCurr] :
      ( v6199(VarCurr)
    <=> ( v6200(VarCurr)
        & v6194(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_297,axiom,
    ! [VarCurr] :
      ( v6200(VarCurr)
    <=> ( v6194(VarCurr,bitIndex1)
        & v6194(VarCurr,bitIndex2) ) ) ).

fof(addAssignment_1580,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6194(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1579,axiom,
    ! [VarCurr] :
      ( v6194(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_42,axiom,
    ! [VarCurr] :
      ( ~ v6177(VarCurr)
     => ( v5715(VarCurr,bitIndex28)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_40,axiom,
    ! [VarCurr] :
      ( v6177(VarCurr)
     => ( v5715(VarCurr,bitIndex28)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_296,axiom,
    ! [VarCurr] :
      ( v6177(VarCurr)
    <=> ( v6179(VarCurr,bitIndex6)
        | v6180(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1119,axiom,
    ! [VarCurr] :
      ( v6180(VarCurr)
    <=> ( v6181(VarCurr)
        & v6190(VarCurr) ) ) ).

fof(writeUnaryOperator_525,axiom,
    ! [VarCurr] :
      ( ~ v6190(VarCurr)
    <=> v6179(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_295,axiom,
    ! [VarCurr] :
      ( v6181(VarCurr)
    <=> ( v6179(VarCurr,bitIndex5)
        | v6182(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1118,axiom,
    ! [VarCurr] :
      ( v6182(VarCurr)
    <=> ( v6183(VarCurr)
        & v6189(VarCurr) ) ) ).

fof(writeUnaryOperator_524,axiom,
    ! [VarCurr] :
      ( ~ v6189(VarCurr)
    <=> v6179(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_294,axiom,
    ! [VarCurr] :
      ( v6183(VarCurr)
    <=> ( v6184(VarCurr)
        & v6179(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorShiftedRanges_293,axiom,
    ! [VarCurr] :
      ( v6184(VarCurr)
    <=> ( v6185(VarCurr)
        & v6179(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_292,axiom,
    ! [VarCurr] :
      ( v6185(VarCurr)
    <=> ( v6186(VarCurr)
        & v6179(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_291,axiom,
    ! [VarCurr] :
      ( v6186(VarCurr)
    <=> ( v6179(VarCurr,bitIndex1)
        | v6187(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1117,axiom,
    ! [VarCurr] :
      ( v6187(VarCurr)
    <=> ( v6179(VarCurr,bitIndex0)
        & v6188(VarCurr) ) ) ).

fof(writeUnaryOperator_523,axiom,
    ! [VarCurr] :
      ( ~ v6188(VarCurr)
    <=> v6179(VarCurr,bitIndex1) ) ).

fof(addAssignment_1578,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6179(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1577,axiom,
    ! [VarCurr] :
      ( v6179(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_41,axiom,
    ! [VarCurr] :
      ( ~ v6166(VarCurr)
     => ( v5715(VarCurr,bitIndex27)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_39,axiom,
    ! [VarCurr] :
      ( v6166(VarCurr)
     => ( v5715(VarCurr,bitIndex27)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_290,axiom,
    ! [VarCurr] :
      ( v6166(VarCurr)
    <=> ( v6168(VarCurr,bitIndex6)
        | v6169(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1116,axiom,
    ! [VarCurr] :
      ( v6169(VarCurr)
    <=> ( v6170(VarCurr)
        & v6175(VarCurr) ) ) ).

fof(writeUnaryOperator_522,axiom,
    ! [VarCurr] :
      ( ~ v6175(VarCurr)
    <=> v6168(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_289,axiom,
    ! [VarCurr] :
      ( v6170(VarCurr)
    <=> ( v6168(VarCurr,bitIndex5)
        | v6171(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1115,axiom,
    ! [VarCurr] :
      ( v6171(VarCurr)
    <=> ( v6172(VarCurr)
        & v6174(VarCurr) ) ) ).

fof(writeUnaryOperator_521,axiom,
    ! [VarCurr] :
      ( ~ v6174(VarCurr)
    <=> v6168(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_288,axiom,
    ! [VarCurr] :
      ( v6172(VarCurr)
    <=> ( v6173(VarCurr)
        & v6168(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorShiftedRanges_287,axiom,
    ! [VarCurr] :
      ( v6173(VarCurr)
    <=> ( v6168(VarCurr,bitIndex2)
        & v6168(VarCurr,bitIndex3) ) ) ).

fof(addAssignment_1576,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6168(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1575,axiom,
    ! [VarCurr] :
      ( v6168(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_40,axiom,
    ! [VarCurr] :
      ( ~ v6151(VarCurr)
     => ( v5715(VarCurr,bitIndex26)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_38,axiom,
    ! [VarCurr] :
      ( v6151(VarCurr)
     => ( v5715(VarCurr,bitIndex26)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_286,axiom,
    ! [VarCurr] :
      ( v6151(VarCurr)
    <=> ( v6153(VarCurr,bitIndex6)
        | v6154(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1114,axiom,
    ! [VarCurr] :
      ( v6154(VarCurr)
    <=> ( v6155(VarCurr)
        & v6164(VarCurr) ) ) ).

fof(writeUnaryOperator_520,axiom,
    ! [VarCurr] :
      ( ~ v6164(VarCurr)
    <=> v6153(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_285,axiom,
    ! [VarCurr] :
      ( v6155(VarCurr)
    <=> ( v6153(VarCurr,bitIndex5)
        | v6156(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1113,axiom,
    ! [VarCurr] :
      ( v6156(VarCurr)
    <=> ( v6157(VarCurr)
        & v6163(VarCurr) ) ) ).

fof(writeUnaryOperator_519,axiom,
    ! [VarCurr] :
      ( ~ v6163(VarCurr)
    <=> v6153(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_284,axiom,
    ! [VarCurr] :
      ( v6157(VarCurr)
    <=> ( v6158(VarCurr)
        & v6153(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorShiftedRanges_283,axiom,
    ! [VarCurr] :
      ( v6158(VarCurr)
    <=> ( v6159(VarCurr)
        & v6153(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_282,axiom,
    ! [VarCurr] :
      ( v6159(VarCurr)
    <=> ( v6153(VarCurr,bitIndex2)
        | v6160(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1112,axiom,
    ! [VarCurr] :
      ( v6160(VarCurr)
    <=> ( v6161(VarCurr)
        & v6162(VarCurr) ) ) ).

fof(writeUnaryOperator_518,axiom,
    ! [VarCurr] :
      ( ~ v6162(VarCurr)
    <=> v6153(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges_281,axiom,
    ! [VarCurr] :
      ( v6161(VarCurr)
    <=> ( v6153(VarCurr,bitIndex0)
        & v6153(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1574,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6153(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1573,axiom,
    ! [VarCurr] :
      ( v6153(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_39,axiom,
    ! [VarCurr] :
      ( ~ v6137(VarCurr)
     => ( v5715(VarCurr,bitIndex25)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_37,axiom,
    ! [VarCurr] :
      ( v6137(VarCurr)
     => ( v5715(VarCurr,bitIndex25)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_280,axiom,
    ! [VarCurr] :
      ( v6137(VarCurr)
    <=> ( v6139(VarCurr,bitIndex6)
        | v6140(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1111,axiom,
    ! [VarCurr] :
      ( v6140(VarCurr)
    <=> ( v6141(VarCurr)
        & v6149(VarCurr) ) ) ).

fof(writeUnaryOperator_517,axiom,
    ! [VarCurr] :
      ( ~ v6149(VarCurr)
    <=> v6139(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_279,axiom,
    ! [VarCurr] :
      ( v6141(VarCurr)
    <=> ( v6139(VarCurr,bitIndex5)
        | v6142(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1110,axiom,
    ! [VarCurr] :
      ( v6142(VarCurr)
    <=> ( v6143(VarCurr)
        & v6148(VarCurr) ) ) ).

fof(writeUnaryOperator_516,axiom,
    ! [VarCurr] :
      ( ~ v6148(VarCurr)
    <=> v6139(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_278,axiom,
    ! [VarCurr] :
      ( v6143(VarCurr)
    <=> ( v6144(VarCurr)
        & v6139(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorShiftedRanges_277,axiom,
    ! [VarCurr] :
      ( v6144(VarCurr)
    <=> ( v6145(VarCurr)
        & v6139(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_276,axiom,
    ! [VarCurr] :
      ( v6145(VarCurr)
    <=> ( v6139(VarCurr,bitIndex2)
        | v6146(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_275,axiom,
    ! [VarCurr] :
      ( v6146(VarCurr)
    <=> ( v6139(VarCurr,bitIndex1)
        & v6147(VarCurr) ) ) ).

fof(writeUnaryOperator_515,axiom,
    ! [VarCurr] :
      ( ~ v6147(VarCurr)
    <=> v6139(VarCurr,bitIndex2) ) ).

fof(addAssignment_1572,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6139(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1571,axiom,
    ! [VarCurr] :
      ( v6139(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_38,axiom,
    ! [VarCurr] :
      ( ~ v6120(VarCurr)
     => ( v5715(VarCurr,bitIndex24)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_36,axiom,
    ! [VarCurr] :
      ( v6120(VarCurr)
     => ( v5715(VarCurr,bitIndex24)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_274,axiom,
    ! [VarCurr] :
      ( v6120(VarCurr)
    <=> ( v6122(VarCurr,bitIndex6)
        | v6123(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1109,axiom,
    ! [VarCurr] :
      ( v6123(VarCurr)
    <=> ( v6124(VarCurr)
        & v6135(VarCurr) ) ) ).

fof(writeUnaryOperator_514,axiom,
    ! [VarCurr] :
      ( ~ v6135(VarCurr)
    <=> v6122(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_273,axiom,
    ! [VarCurr] :
      ( v6124(VarCurr)
    <=> ( v6122(VarCurr,bitIndex5)
        | v6125(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1108,axiom,
    ! [VarCurr] :
      ( v6125(VarCurr)
    <=> ( v6126(VarCurr)
        & v6134(VarCurr) ) ) ).

fof(writeUnaryOperator_513,axiom,
    ! [VarCurr] :
      ( ~ v6134(VarCurr)
    <=> v6122(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_272,axiom,
    ! [VarCurr] :
      ( v6126(VarCurr)
    <=> ( v6127(VarCurr)
        & v6122(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorShiftedRanges_271,axiom,
    ! [VarCurr] :
      ( v6127(VarCurr)
    <=> ( v6128(VarCurr)
        & v6122(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_270,axiom,
    ! [VarCurr] :
      ( v6128(VarCurr)
    <=> ( v6122(VarCurr,bitIndex2)
        | v6129(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1107,axiom,
    ! [VarCurr] :
      ( v6129(VarCurr)
    <=> ( v6130(VarCurr)
        & v6133(VarCurr) ) ) ).

fof(writeUnaryOperator_512,axiom,
    ! [VarCurr] :
      ( ~ v6133(VarCurr)
    <=> v6122(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges_269,axiom,
    ! [VarCurr] :
      ( v6130(VarCurr)
    <=> ( v6122(VarCurr,bitIndex1)
        | v6131(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1106,axiom,
    ! [VarCurr] :
      ( v6131(VarCurr)
    <=> ( v6122(VarCurr,bitIndex0)
        & v6132(VarCurr) ) ) ).

fof(writeUnaryOperator_511,axiom,
    ! [VarCurr] :
      ( ~ v6132(VarCurr)
    <=> v6122(VarCurr,bitIndex1) ) ).

fof(addAssignment_1570,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6122(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1569,axiom,
    ! [VarCurr] :
      ( v6122(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_37,axiom,
    ! [VarCurr] :
      ( ~ v6110(VarCurr)
     => ( v5715(VarCurr,bitIndex23)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_35,axiom,
    ! [VarCurr] :
      ( v6110(VarCurr)
     => ( v5715(VarCurr,bitIndex23)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_268,axiom,
    ! [VarCurr] :
      ( v6110(VarCurr)
    <=> ( v6112(VarCurr,bitIndex6)
        | v6113(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1105,axiom,
    ! [VarCurr] :
      ( v6113(VarCurr)
    <=> ( v6114(VarCurr)
        & v6118(VarCurr) ) ) ).

fof(writeUnaryOperator_510,axiom,
    ! [VarCurr] :
      ( ~ v6118(VarCurr)
    <=> v6112(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_267,axiom,
    ! [VarCurr] :
      ( v6114(VarCurr)
    <=> ( v6112(VarCurr,bitIndex5)
        | v6115(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1104,axiom,
    ! [VarCurr] :
      ( v6115(VarCurr)
    <=> ( v6116(VarCurr)
        & v6117(VarCurr) ) ) ).

fof(writeUnaryOperator_509,axiom,
    ! [VarCurr] :
      ( ~ v6117(VarCurr)
    <=> v6112(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_266,axiom,
    ! [VarCurr] :
      ( v6116(VarCurr)
    <=> ( v6112(VarCurr,bitIndex3)
        & v6112(VarCurr,bitIndex4) ) ) ).

fof(addAssignment_1568,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6112(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1567,axiom,
    ! [VarCurr] :
      ( v6112(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_36,axiom,
    ! [VarCurr] :
      ( ~ v6095(VarCurr)
     => ( v5715(VarCurr,bitIndex22)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_34,axiom,
    ! [VarCurr] :
      ( v6095(VarCurr)
     => ( v5715(VarCurr,bitIndex22)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_265,axiom,
    ! [VarCurr] :
      ( v6095(VarCurr)
    <=> ( v6097(VarCurr,bitIndex6)
        | v6098(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1103,axiom,
    ! [VarCurr] :
      ( v6098(VarCurr)
    <=> ( v6099(VarCurr)
        & v6108(VarCurr) ) ) ).

fof(writeUnaryOperator_508,axiom,
    ! [VarCurr] :
      ( ~ v6108(VarCurr)
    <=> v6097(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_264,axiom,
    ! [VarCurr] :
      ( v6099(VarCurr)
    <=> ( v6097(VarCurr,bitIndex5)
        | v6100(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1102,axiom,
    ! [VarCurr] :
      ( v6100(VarCurr)
    <=> ( v6101(VarCurr)
        & v6107(VarCurr) ) ) ).

fof(writeUnaryOperator_507,axiom,
    ! [VarCurr] :
      ( ~ v6107(VarCurr)
    <=> v6097(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_263,axiom,
    ! [VarCurr] :
      ( v6101(VarCurr)
    <=> ( v6102(VarCurr)
        & v6097(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorShiftedRanges_262,axiom,
    ! [VarCurr] :
      ( v6102(VarCurr)
    <=> ( v6097(VarCurr,bitIndex3)
        | v6103(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1101,axiom,
    ! [VarCurr] :
      ( v6103(VarCurr)
    <=> ( v6104(VarCurr)
        & v6106(VarCurr) ) ) ).

fof(writeUnaryOperator_506,axiom,
    ! [VarCurr] :
      ( ~ v6106(VarCurr)
    <=> v6097(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_261,axiom,
    ! [VarCurr] :
      ( v6104(VarCurr)
    <=> ( v6105(VarCurr)
        & v6097(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_260,axiom,
    ! [VarCurr] :
      ( v6105(VarCurr)
    <=> ( v6097(VarCurr,bitIndex0)
        & v6097(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1566,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6097(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1565,axiom,
    ! [VarCurr] :
      ( v6097(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_35,axiom,
    ! [VarCurr] :
      ( ~ v6081(VarCurr)
     => ( v5715(VarCurr,bitIndex21)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_33,axiom,
    ! [VarCurr] :
      ( v6081(VarCurr)
     => ( v5715(VarCurr,bitIndex21)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_259,axiom,
    ! [VarCurr] :
      ( v6081(VarCurr)
    <=> ( v6083(VarCurr,bitIndex6)
        | v6084(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1100,axiom,
    ! [VarCurr] :
      ( v6084(VarCurr)
    <=> ( v6085(VarCurr)
        & v6093(VarCurr) ) ) ).

fof(writeUnaryOperator_505,axiom,
    ! [VarCurr] :
      ( ~ v6093(VarCurr)
    <=> v6083(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_258,axiom,
    ! [VarCurr] :
      ( v6085(VarCurr)
    <=> ( v6083(VarCurr,bitIndex5)
        | v6086(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1099,axiom,
    ! [VarCurr] :
      ( v6086(VarCurr)
    <=> ( v6087(VarCurr)
        & v6092(VarCurr) ) ) ).

fof(writeUnaryOperator_504,axiom,
    ! [VarCurr] :
      ( ~ v6092(VarCurr)
    <=> v6083(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_257,axiom,
    ! [VarCurr] :
      ( v6087(VarCurr)
    <=> ( v6088(VarCurr)
        & v6083(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorShiftedRanges_256,axiom,
    ! [VarCurr] :
      ( v6088(VarCurr)
    <=> ( v6083(VarCurr,bitIndex3)
        | v6089(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1098,axiom,
    ! [VarCurr] :
      ( v6089(VarCurr)
    <=> ( v6090(VarCurr)
        & v6091(VarCurr) ) ) ).

fof(writeUnaryOperator_503,axiom,
    ! [VarCurr] :
      ( ~ v6091(VarCurr)
    <=> v6083(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_255,axiom,
    ! [VarCurr] :
      ( v6090(VarCurr)
    <=> ( v6083(VarCurr,bitIndex1)
        & v6083(VarCurr,bitIndex2) ) ) ).

fof(addAssignment_1564,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6083(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1563,axiom,
    ! [VarCurr] :
      ( v6083(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_34,axiom,
    ! [VarCurr] :
      ( ~ v6064(VarCurr)
     => ( v5715(VarCurr,bitIndex20)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_32,axiom,
    ! [VarCurr] :
      ( v6064(VarCurr)
     => ( v5715(VarCurr,bitIndex20)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_254,axiom,
    ! [VarCurr] :
      ( v6064(VarCurr)
    <=> ( v6066(VarCurr,bitIndex6)
        | v6067(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1097,axiom,
    ! [VarCurr] :
      ( v6067(VarCurr)
    <=> ( v6068(VarCurr)
        & v6079(VarCurr) ) ) ).

fof(writeUnaryOperator_502,axiom,
    ! [VarCurr] :
      ( ~ v6079(VarCurr)
    <=> v6066(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_253,axiom,
    ! [VarCurr] :
      ( v6068(VarCurr)
    <=> ( v6066(VarCurr,bitIndex5)
        | v6069(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1096,axiom,
    ! [VarCurr] :
      ( v6069(VarCurr)
    <=> ( v6070(VarCurr)
        & v6078(VarCurr) ) ) ).

fof(writeUnaryOperator_501,axiom,
    ! [VarCurr] :
      ( ~ v6078(VarCurr)
    <=> v6066(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_252,axiom,
    ! [VarCurr] :
      ( v6070(VarCurr)
    <=> ( v6071(VarCurr)
        & v6066(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorShiftedRanges_251,axiom,
    ! [VarCurr] :
      ( v6071(VarCurr)
    <=> ( v6066(VarCurr,bitIndex3)
        | v6072(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1095,axiom,
    ! [VarCurr] :
      ( v6072(VarCurr)
    <=> ( v6073(VarCurr)
        & v6077(VarCurr) ) ) ).

fof(writeUnaryOperator_500,axiom,
    ! [VarCurr] :
      ( ~ v6077(VarCurr)
    <=> v6066(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_250,axiom,
    ! [VarCurr] :
      ( v6073(VarCurr)
    <=> ( v6074(VarCurr)
        & v6066(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_249,axiom,
    ! [VarCurr] :
      ( v6074(VarCurr)
    <=> ( v6066(VarCurr,bitIndex1)
        | v6075(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1094,axiom,
    ! [VarCurr] :
      ( v6075(VarCurr)
    <=> ( v6066(VarCurr,bitIndex0)
        & v6076(VarCurr) ) ) ).

fof(writeUnaryOperator_499,axiom,
    ! [VarCurr] :
      ( ~ v6076(VarCurr)
    <=> v6066(VarCurr,bitIndex1) ) ).

fof(addAssignment_1562,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6066(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1561,axiom,
    ! [VarCurr] :
      ( v6066(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_33,axiom,
    ! [VarCurr] :
      ( ~ v6051(VarCurr)
     => ( v5715(VarCurr,bitIndex19)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_31,axiom,
    ! [VarCurr] :
      ( v6051(VarCurr)
     => ( v5715(VarCurr,bitIndex19)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_248,axiom,
    ! [VarCurr] :
      ( v6051(VarCurr)
    <=> ( v6053(VarCurr,bitIndex6)
        | v6054(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1093,axiom,
    ! [VarCurr] :
      ( v6054(VarCurr)
    <=> ( v6055(VarCurr)
        & v6062(VarCurr) ) ) ).

fof(writeUnaryOperator_498,axiom,
    ! [VarCurr] :
      ( ~ v6062(VarCurr)
    <=> v6053(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_247,axiom,
    ! [VarCurr] :
      ( v6055(VarCurr)
    <=> ( v6053(VarCurr,bitIndex5)
        | v6056(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1092,axiom,
    ! [VarCurr] :
      ( v6056(VarCurr)
    <=> ( v6057(VarCurr)
        & v6061(VarCurr) ) ) ).

fof(writeUnaryOperator_497,axiom,
    ! [VarCurr] :
      ( ~ v6061(VarCurr)
    <=> v6053(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_246,axiom,
    ! [VarCurr] :
      ( v6057(VarCurr)
    <=> ( v6058(VarCurr)
        & v6053(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorShiftedRanges_245,axiom,
    ! [VarCurr] :
      ( v6058(VarCurr)
    <=> ( v6053(VarCurr,bitIndex3)
        | v6059(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_244,axiom,
    ! [VarCurr] :
      ( v6059(VarCurr)
    <=> ( v6053(VarCurr,bitIndex2)
        & v6060(VarCurr) ) ) ).

fof(writeUnaryOperator_496,axiom,
    ! [VarCurr] :
      ( ~ v6060(VarCurr)
    <=> v6053(VarCurr,bitIndex3) ) ).

fof(addAssignment_1560,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6053(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1559,axiom,
    ! [VarCurr] :
      ( v6053(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_32,axiom,
    ! [VarCurr] :
      ( ~ v6034(VarCurr)
     => ( v5715(VarCurr,bitIndex18)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_30,axiom,
    ! [VarCurr] :
      ( v6034(VarCurr)
     => ( v5715(VarCurr,bitIndex18)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_243,axiom,
    ! [VarCurr] :
      ( v6034(VarCurr)
    <=> ( v6036(VarCurr,bitIndex6)
        | v6037(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1091,axiom,
    ! [VarCurr] :
      ( v6037(VarCurr)
    <=> ( v6038(VarCurr)
        & v6049(VarCurr) ) ) ).

fof(writeUnaryOperator_495,axiom,
    ! [VarCurr] :
      ( ~ v6049(VarCurr)
    <=> v6036(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_242,axiom,
    ! [VarCurr] :
      ( v6038(VarCurr)
    <=> ( v6036(VarCurr,bitIndex5)
        | v6039(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1090,axiom,
    ! [VarCurr] :
      ( v6039(VarCurr)
    <=> ( v6040(VarCurr)
        & v6048(VarCurr) ) ) ).

fof(writeUnaryOperator_494,axiom,
    ! [VarCurr] :
      ( ~ v6048(VarCurr)
    <=> v6036(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_241,axiom,
    ! [VarCurr] :
      ( v6040(VarCurr)
    <=> ( v6041(VarCurr)
        & v6036(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorShiftedRanges_240,axiom,
    ! [VarCurr] :
      ( v6041(VarCurr)
    <=> ( v6036(VarCurr,bitIndex3)
        | v6042(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1089,axiom,
    ! [VarCurr] :
      ( v6042(VarCurr)
    <=> ( v6043(VarCurr)
        & v6047(VarCurr) ) ) ).

fof(writeUnaryOperator_493,axiom,
    ! [VarCurr] :
      ( ~ v6047(VarCurr)
    <=> v6036(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_239,axiom,
    ! [VarCurr] :
      ( v6043(VarCurr)
    <=> ( v6036(VarCurr,bitIndex2)
        | v6044(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1088,axiom,
    ! [VarCurr] :
      ( v6044(VarCurr)
    <=> ( v6045(VarCurr)
        & v6046(VarCurr) ) ) ).

fof(writeUnaryOperator_492,axiom,
    ! [VarCurr] :
      ( ~ v6046(VarCurr)
    <=> v6036(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges_238,axiom,
    ! [VarCurr] :
      ( v6045(VarCurr)
    <=> ( v6036(VarCurr,bitIndex0)
        & v6036(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1558,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6036(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1557,axiom,
    ! [VarCurr] :
      ( v6036(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_31,axiom,
    ! [VarCurr] :
      ( ~ v6018(VarCurr)
     => ( v5715(VarCurr,bitIndex17)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_29,axiom,
    ! [VarCurr] :
      ( v6018(VarCurr)
     => ( v5715(VarCurr,bitIndex17)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_237,axiom,
    ! [VarCurr] :
      ( v6018(VarCurr)
    <=> ( v6020(VarCurr,bitIndex6)
        | v6021(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1087,axiom,
    ! [VarCurr] :
      ( v6021(VarCurr)
    <=> ( v6022(VarCurr)
        & v6032(VarCurr) ) ) ).

fof(writeUnaryOperator_491,axiom,
    ! [VarCurr] :
      ( ~ v6032(VarCurr)
    <=> v6020(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_236,axiom,
    ! [VarCurr] :
      ( v6022(VarCurr)
    <=> ( v6020(VarCurr,bitIndex5)
        | v6023(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1086,axiom,
    ! [VarCurr] :
      ( v6023(VarCurr)
    <=> ( v6024(VarCurr)
        & v6031(VarCurr) ) ) ).

fof(writeUnaryOperator_490,axiom,
    ! [VarCurr] :
      ( ~ v6031(VarCurr)
    <=> v6020(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_235,axiom,
    ! [VarCurr] :
      ( v6024(VarCurr)
    <=> ( v6025(VarCurr)
        & v6020(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorShiftedRanges_234,axiom,
    ! [VarCurr] :
      ( v6025(VarCurr)
    <=> ( v6020(VarCurr,bitIndex3)
        | v6026(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1085,axiom,
    ! [VarCurr] :
      ( v6026(VarCurr)
    <=> ( v6027(VarCurr)
        & v6030(VarCurr) ) ) ).

fof(writeUnaryOperator_489,axiom,
    ! [VarCurr] :
      ( ~ v6030(VarCurr)
    <=> v6020(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_233,axiom,
    ! [VarCurr] :
      ( v6027(VarCurr)
    <=> ( v6020(VarCurr,bitIndex2)
        | v6028(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_232,axiom,
    ! [VarCurr] :
      ( v6028(VarCurr)
    <=> ( v6020(VarCurr,bitIndex1)
        & v6029(VarCurr) ) ) ).

fof(writeUnaryOperator_488,axiom,
    ! [VarCurr] :
      ( ~ v6029(VarCurr)
    <=> v6020(VarCurr,bitIndex2) ) ).

fof(addAssignment_1556,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6020(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1555,axiom,
    ! [VarCurr] :
      ( v6020(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_30,axiom,
    ! [VarCurr] :
      ( ~ v5999(VarCurr)
     => ( v5715(VarCurr,bitIndex16)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_28,axiom,
    ! [VarCurr] :
      ( v5999(VarCurr)
     => ( v5715(VarCurr,bitIndex16)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_231,axiom,
    ! [VarCurr] :
      ( v5999(VarCurr)
    <=> ( v6001(VarCurr,bitIndex6)
        | v6002(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1084,axiom,
    ! [VarCurr] :
      ( v6002(VarCurr)
    <=> ( v6003(VarCurr)
        & v6016(VarCurr) ) ) ).

fof(writeUnaryOperator_487,axiom,
    ! [VarCurr] :
      ( ~ v6016(VarCurr)
    <=> v6001(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_230,axiom,
    ! [VarCurr] :
      ( v6003(VarCurr)
    <=> ( v6001(VarCurr,bitIndex5)
        | v6004(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1083,axiom,
    ! [VarCurr] :
      ( v6004(VarCurr)
    <=> ( v6005(VarCurr)
        & v6015(VarCurr) ) ) ).

fof(writeUnaryOperator_486,axiom,
    ! [VarCurr] :
      ( ~ v6015(VarCurr)
    <=> v6001(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_229,axiom,
    ! [VarCurr] :
      ( v6005(VarCurr)
    <=> ( v6006(VarCurr)
        & v6001(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorShiftedRanges_228,axiom,
    ! [VarCurr] :
      ( v6006(VarCurr)
    <=> ( v6001(VarCurr,bitIndex3)
        | v6007(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1082,axiom,
    ! [VarCurr] :
      ( v6007(VarCurr)
    <=> ( v6008(VarCurr)
        & v6014(VarCurr) ) ) ).

fof(writeUnaryOperator_485,axiom,
    ! [VarCurr] :
      ( ~ v6014(VarCurr)
    <=> v6001(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_227,axiom,
    ! [VarCurr] :
      ( v6008(VarCurr)
    <=> ( v6001(VarCurr,bitIndex2)
        | v6009(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1081,axiom,
    ! [VarCurr] :
      ( v6009(VarCurr)
    <=> ( v6010(VarCurr)
        & v6013(VarCurr) ) ) ).

fof(writeUnaryOperator_484,axiom,
    ! [VarCurr] :
      ( ~ v6013(VarCurr)
    <=> v6001(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges_226,axiom,
    ! [VarCurr] :
      ( v6010(VarCurr)
    <=> ( v6001(VarCurr,bitIndex1)
        | v6011(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1080,axiom,
    ! [VarCurr] :
      ( v6011(VarCurr)
    <=> ( v6001(VarCurr,bitIndex0)
        & v6012(VarCurr) ) ) ).

fof(writeUnaryOperator_483,axiom,
    ! [VarCurr] :
      ( ~ v6012(VarCurr)
    <=> v6001(VarCurr,bitIndex1) ) ).

fof(addAssignment_1554,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v6001(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1553,axiom,
    ! [VarCurr] :
      ( v6001(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_29,axiom,
    ! [VarCurr] :
      ( ~ v5990(VarCurr)
     => ( v5715(VarCurr,bitIndex15)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_27,axiom,
    ! [VarCurr] :
      ( v5990(VarCurr)
     => ( v5715(VarCurr,bitIndex15)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_225,axiom,
    ! [VarCurr] :
      ( v5990(VarCurr)
    <=> ( v5992(VarCurr,bitIndex6)
        | v5993(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1079,axiom,
    ! [VarCurr] :
      ( v5993(VarCurr)
    <=> ( v5994(VarCurr)
        & v5997(VarCurr) ) ) ).

fof(writeUnaryOperator_482,axiom,
    ! [VarCurr] :
      ( ~ v5997(VarCurr)
    <=> v5992(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_224,axiom,
    ! [VarCurr] :
      ( v5994(VarCurr)
    <=> ( v5992(VarCurr,bitIndex5)
        | v5995(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_223,axiom,
    ! [VarCurr] :
      ( v5995(VarCurr)
    <=> ( v5992(VarCurr,bitIndex4)
        & v5996(VarCurr) ) ) ).

fof(writeUnaryOperator_481,axiom,
    ! [VarCurr] :
      ( ~ v5996(VarCurr)
    <=> v5992(VarCurr,bitIndex5) ) ).

fof(addAssignment_1552,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5992(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1551,axiom,
    ! [VarCurr] :
      ( v5992(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_28,axiom,
    ! [VarCurr] :
      ( ~ v5975(VarCurr)
     => ( v5715(VarCurr,bitIndex14)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_26,axiom,
    ! [VarCurr] :
      ( v5975(VarCurr)
     => ( v5715(VarCurr,bitIndex14)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_222,axiom,
    ! [VarCurr] :
      ( v5975(VarCurr)
    <=> ( v5977(VarCurr,bitIndex6)
        | v5978(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1078,axiom,
    ! [VarCurr] :
      ( v5978(VarCurr)
    <=> ( v5979(VarCurr)
        & v5988(VarCurr) ) ) ).

fof(writeUnaryOperator_480,axiom,
    ! [VarCurr] :
      ( ~ v5988(VarCurr)
    <=> v5977(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_221,axiom,
    ! [VarCurr] :
      ( v5979(VarCurr)
    <=> ( v5977(VarCurr,bitIndex5)
        | v5980(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1077,axiom,
    ! [VarCurr] :
      ( v5980(VarCurr)
    <=> ( v5981(VarCurr)
        & v5987(VarCurr) ) ) ).

fof(writeUnaryOperator_479,axiom,
    ! [VarCurr] :
      ( ~ v5987(VarCurr)
    <=> v5977(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_220,axiom,
    ! [VarCurr] :
      ( v5981(VarCurr)
    <=> ( v5977(VarCurr,bitIndex4)
        | v5982(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1076,axiom,
    ! [VarCurr] :
      ( v5982(VarCurr)
    <=> ( v5983(VarCurr)
        & v5986(VarCurr) ) ) ).

fof(writeUnaryOperator_478,axiom,
    ! [VarCurr] :
      ( ~ v5986(VarCurr)
    <=> v5977(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_219,axiom,
    ! [VarCurr] :
      ( v5983(VarCurr)
    <=> ( v5984(VarCurr)
        & v5977(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_218,axiom,
    ! [VarCurr] :
      ( v5984(VarCurr)
    <=> ( v5985(VarCurr)
        & v5977(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_217,axiom,
    ! [VarCurr] :
      ( v5985(VarCurr)
    <=> ( v5977(VarCurr,bitIndex0)
        & v5977(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1550,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5977(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1549,axiom,
    ! [VarCurr] :
      ( v5977(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_27,axiom,
    ! [VarCurr] :
      ( ~ v5961(VarCurr)
     => ( v5715(VarCurr,bitIndex13)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_25,axiom,
    ! [VarCurr] :
      ( v5961(VarCurr)
     => ( v5715(VarCurr,bitIndex13)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_216,axiom,
    ! [VarCurr] :
      ( v5961(VarCurr)
    <=> ( v5963(VarCurr,bitIndex6)
        | v5964(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1075,axiom,
    ! [VarCurr] :
      ( v5964(VarCurr)
    <=> ( v5965(VarCurr)
        & v5973(VarCurr) ) ) ).

fof(writeUnaryOperator_477,axiom,
    ! [VarCurr] :
      ( ~ v5973(VarCurr)
    <=> v5963(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_215,axiom,
    ! [VarCurr] :
      ( v5965(VarCurr)
    <=> ( v5963(VarCurr,bitIndex5)
        | v5966(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1074,axiom,
    ! [VarCurr] :
      ( v5966(VarCurr)
    <=> ( v5967(VarCurr)
        & v5972(VarCurr) ) ) ).

fof(writeUnaryOperator_476,axiom,
    ! [VarCurr] :
      ( ~ v5972(VarCurr)
    <=> v5963(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_214,axiom,
    ! [VarCurr] :
      ( v5967(VarCurr)
    <=> ( v5963(VarCurr,bitIndex4)
        | v5968(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1073,axiom,
    ! [VarCurr] :
      ( v5968(VarCurr)
    <=> ( v5969(VarCurr)
        & v5971(VarCurr) ) ) ).

fof(writeUnaryOperator_475,axiom,
    ! [VarCurr] :
      ( ~ v5971(VarCurr)
    <=> v5963(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_213,axiom,
    ! [VarCurr] :
      ( v5969(VarCurr)
    <=> ( v5970(VarCurr)
        & v5963(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_212,axiom,
    ! [VarCurr] :
      ( v5970(VarCurr)
    <=> ( v5963(VarCurr,bitIndex1)
        & v5963(VarCurr,bitIndex2) ) ) ).

fof(addAssignment_1548,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5963(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1547,axiom,
    ! [VarCurr] :
      ( v5963(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_26,axiom,
    ! [VarCurr] :
      ( ~ v5944(VarCurr)
     => ( v5715(VarCurr,bitIndex12)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_24,axiom,
    ! [VarCurr] :
      ( v5944(VarCurr)
     => ( v5715(VarCurr,bitIndex12)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_211,axiom,
    ! [VarCurr] :
      ( v5944(VarCurr)
    <=> ( v5946(VarCurr,bitIndex6)
        | v5947(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1072,axiom,
    ! [VarCurr] :
      ( v5947(VarCurr)
    <=> ( v5948(VarCurr)
        & v5959(VarCurr) ) ) ).

fof(writeUnaryOperator_474,axiom,
    ! [VarCurr] :
      ( ~ v5959(VarCurr)
    <=> v5946(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_210,axiom,
    ! [VarCurr] :
      ( v5948(VarCurr)
    <=> ( v5946(VarCurr,bitIndex5)
        | v5949(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1071,axiom,
    ! [VarCurr] :
      ( v5949(VarCurr)
    <=> ( v5950(VarCurr)
        & v5958(VarCurr) ) ) ).

fof(writeUnaryOperator_473,axiom,
    ! [VarCurr] :
      ( ~ v5958(VarCurr)
    <=> v5946(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_209,axiom,
    ! [VarCurr] :
      ( v5950(VarCurr)
    <=> ( v5946(VarCurr,bitIndex4)
        | v5951(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1070,axiom,
    ! [VarCurr] :
      ( v5951(VarCurr)
    <=> ( v5952(VarCurr)
        & v5957(VarCurr) ) ) ).

fof(writeUnaryOperator_472,axiom,
    ! [VarCurr] :
      ( ~ v5957(VarCurr)
    <=> v5946(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_208,axiom,
    ! [VarCurr] :
      ( v5952(VarCurr)
    <=> ( v5953(VarCurr)
        & v5946(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_207,axiom,
    ! [VarCurr] :
      ( v5953(VarCurr)
    <=> ( v5954(VarCurr)
        & v5946(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_206,axiom,
    ! [VarCurr] :
      ( v5954(VarCurr)
    <=> ( v5946(VarCurr,bitIndex1)
        | v5955(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1069,axiom,
    ! [VarCurr] :
      ( v5955(VarCurr)
    <=> ( v5946(VarCurr,bitIndex0)
        & v5956(VarCurr) ) ) ).

fof(writeUnaryOperator_471,axiom,
    ! [VarCurr] :
      ( ~ v5956(VarCurr)
    <=> v5946(VarCurr,bitIndex1) ) ).

fof(addAssignment_1546,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5946(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1545,axiom,
    ! [VarCurr] :
      ( v5946(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_25,axiom,
    ! [VarCurr] :
      ( ~ v5931(VarCurr)
     => ( v5715(VarCurr,bitIndex11)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_23,axiom,
    ! [VarCurr] :
      ( v5931(VarCurr)
     => ( v5715(VarCurr,bitIndex11)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_205,axiom,
    ! [VarCurr] :
      ( v5931(VarCurr)
    <=> ( v5933(VarCurr,bitIndex6)
        | v5934(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1068,axiom,
    ! [VarCurr] :
      ( v5934(VarCurr)
    <=> ( v5935(VarCurr)
        & v5942(VarCurr) ) ) ).

fof(writeUnaryOperator_470,axiom,
    ! [VarCurr] :
      ( ~ v5942(VarCurr)
    <=> v5933(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_204,axiom,
    ! [VarCurr] :
      ( v5935(VarCurr)
    <=> ( v5933(VarCurr,bitIndex5)
        | v5936(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1067,axiom,
    ! [VarCurr] :
      ( v5936(VarCurr)
    <=> ( v5937(VarCurr)
        & v5941(VarCurr) ) ) ).

fof(writeUnaryOperator_469,axiom,
    ! [VarCurr] :
      ( ~ v5941(VarCurr)
    <=> v5933(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_203,axiom,
    ! [VarCurr] :
      ( v5937(VarCurr)
    <=> ( v5933(VarCurr,bitIndex4)
        | v5938(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1066,axiom,
    ! [VarCurr] :
      ( v5938(VarCurr)
    <=> ( v5939(VarCurr)
        & v5940(VarCurr) ) ) ).

fof(writeUnaryOperator_468,axiom,
    ! [VarCurr] :
      ( ~ v5940(VarCurr)
    <=> v5933(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_202,axiom,
    ! [VarCurr] :
      ( v5939(VarCurr)
    <=> ( v5933(VarCurr,bitIndex2)
        & v5933(VarCurr,bitIndex3) ) ) ).

fof(addAssignment_1544,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5933(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1543,axiom,
    ! [VarCurr] :
      ( v5933(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_24,axiom,
    ! [VarCurr] :
      ( ~ v5914(VarCurr)
     => ( v5715(VarCurr,bitIndex10)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_22,axiom,
    ! [VarCurr] :
      ( v5914(VarCurr)
     => ( v5715(VarCurr,bitIndex10)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_201,axiom,
    ! [VarCurr] :
      ( v5914(VarCurr)
    <=> ( v5916(VarCurr,bitIndex6)
        | v5917(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1065,axiom,
    ! [VarCurr] :
      ( v5917(VarCurr)
    <=> ( v5918(VarCurr)
        & v5929(VarCurr) ) ) ).

fof(writeUnaryOperator_467,axiom,
    ! [VarCurr] :
      ( ~ v5929(VarCurr)
    <=> v5916(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_200,axiom,
    ! [VarCurr] :
      ( v5918(VarCurr)
    <=> ( v5916(VarCurr,bitIndex5)
        | v5919(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1064,axiom,
    ! [VarCurr] :
      ( v5919(VarCurr)
    <=> ( v5920(VarCurr)
        & v5928(VarCurr) ) ) ).

fof(writeUnaryOperator_466,axiom,
    ! [VarCurr] :
      ( ~ v5928(VarCurr)
    <=> v5916(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_199,axiom,
    ! [VarCurr] :
      ( v5920(VarCurr)
    <=> ( v5916(VarCurr,bitIndex4)
        | v5921(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1063,axiom,
    ! [VarCurr] :
      ( v5921(VarCurr)
    <=> ( v5922(VarCurr)
        & v5927(VarCurr) ) ) ).

fof(writeUnaryOperator_465,axiom,
    ! [VarCurr] :
      ( ~ v5927(VarCurr)
    <=> v5916(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_198,axiom,
    ! [VarCurr] :
      ( v5922(VarCurr)
    <=> ( v5923(VarCurr)
        & v5916(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_197,axiom,
    ! [VarCurr] :
      ( v5923(VarCurr)
    <=> ( v5916(VarCurr,bitIndex2)
        | v5924(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1062,axiom,
    ! [VarCurr] :
      ( v5924(VarCurr)
    <=> ( v5925(VarCurr)
        & v5926(VarCurr) ) ) ).

fof(writeUnaryOperator_464,axiom,
    ! [VarCurr] :
      ( ~ v5926(VarCurr)
    <=> v5916(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges_196,axiom,
    ! [VarCurr] :
      ( v5925(VarCurr)
    <=> ( v5916(VarCurr,bitIndex0)
        & v5916(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1542,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5916(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1541,axiom,
    ! [VarCurr] :
      ( v5916(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_23,axiom,
    ! [VarCurr] :
      ( ~ v5898(VarCurr)
     => ( v5715(VarCurr,bitIndex9)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_21,axiom,
    ! [VarCurr] :
      ( v5898(VarCurr)
     => ( v5715(VarCurr,bitIndex9)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_195,axiom,
    ! [VarCurr] :
      ( v5898(VarCurr)
    <=> ( v5900(VarCurr,bitIndex6)
        | v5901(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1061,axiom,
    ! [VarCurr] :
      ( v5901(VarCurr)
    <=> ( v5902(VarCurr)
        & v5912(VarCurr) ) ) ).

fof(writeUnaryOperator_463,axiom,
    ! [VarCurr] :
      ( ~ v5912(VarCurr)
    <=> v5900(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_194,axiom,
    ! [VarCurr] :
      ( v5902(VarCurr)
    <=> ( v5900(VarCurr,bitIndex5)
        | v5903(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1060,axiom,
    ! [VarCurr] :
      ( v5903(VarCurr)
    <=> ( v5904(VarCurr)
        & v5911(VarCurr) ) ) ).

fof(writeUnaryOperator_462,axiom,
    ! [VarCurr] :
      ( ~ v5911(VarCurr)
    <=> v5900(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_193,axiom,
    ! [VarCurr] :
      ( v5904(VarCurr)
    <=> ( v5900(VarCurr,bitIndex4)
        | v5905(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1059,axiom,
    ! [VarCurr] :
      ( v5905(VarCurr)
    <=> ( v5906(VarCurr)
        & v5910(VarCurr) ) ) ).

fof(writeUnaryOperator_461,axiom,
    ! [VarCurr] :
      ( ~ v5910(VarCurr)
    <=> v5900(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_192,axiom,
    ! [VarCurr] :
      ( v5906(VarCurr)
    <=> ( v5907(VarCurr)
        & v5900(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_191,axiom,
    ! [VarCurr] :
      ( v5907(VarCurr)
    <=> ( v5900(VarCurr,bitIndex2)
        | v5908(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_190,axiom,
    ! [VarCurr] :
      ( v5908(VarCurr)
    <=> ( v5900(VarCurr,bitIndex1)
        & v5909(VarCurr) ) ) ).

fof(writeUnaryOperator_460,axiom,
    ! [VarCurr] :
      ( ~ v5909(VarCurr)
    <=> v5900(VarCurr,bitIndex2) ) ).

fof(addAssignment_1540,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5900(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1539,axiom,
    ! [VarCurr] :
      ( v5900(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_22,axiom,
    ! [VarCurr] :
      ( ~ v5879(VarCurr)
     => ( v5715(VarCurr,bitIndex8)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_20,axiom,
    ! [VarCurr] :
      ( v5879(VarCurr)
     => ( v5715(VarCurr,bitIndex8)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_189,axiom,
    ! [VarCurr] :
      ( v5879(VarCurr)
    <=> ( v5881(VarCurr,bitIndex6)
        | v5882(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1058,axiom,
    ! [VarCurr] :
      ( v5882(VarCurr)
    <=> ( v5883(VarCurr)
        & v5896(VarCurr) ) ) ).

fof(writeUnaryOperator_459,axiom,
    ! [VarCurr] :
      ( ~ v5896(VarCurr)
    <=> v5881(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_188,axiom,
    ! [VarCurr] :
      ( v5883(VarCurr)
    <=> ( v5881(VarCurr,bitIndex5)
        | v5884(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1057,axiom,
    ! [VarCurr] :
      ( v5884(VarCurr)
    <=> ( v5885(VarCurr)
        & v5895(VarCurr) ) ) ).

fof(writeUnaryOperator_458,axiom,
    ! [VarCurr] :
      ( ~ v5895(VarCurr)
    <=> v5881(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_187,axiom,
    ! [VarCurr] :
      ( v5885(VarCurr)
    <=> ( v5881(VarCurr,bitIndex4)
        | v5886(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1056,axiom,
    ! [VarCurr] :
      ( v5886(VarCurr)
    <=> ( v5887(VarCurr)
        & v5894(VarCurr) ) ) ).

fof(writeUnaryOperator_457,axiom,
    ! [VarCurr] :
      ( ~ v5894(VarCurr)
    <=> v5881(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_186,axiom,
    ! [VarCurr] :
      ( v5887(VarCurr)
    <=> ( v5888(VarCurr)
        & v5881(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_185,axiom,
    ! [VarCurr] :
      ( v5888(VarCurr)
    <=> ( v5881(VarCurr,bitIndex2)
        | v5889(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1055,axiom,
    ! [VarCurr] :
      ( v5889(VarCurr)
    <=> ( v5890(VarCurr)
        & v5893(VarCurr) ) ) ).

fof(writeUnaryOperator_456,axiom,
    ! [VarCurr] :
      ( ~ v5893(VarCurr)
    <=> v5881(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges_184,axiom,
    ! [VarCurr] :
      ( v5890(VarCurr)
    <=> ( v5881(VarCurr,bitIndex1)
        | v5891(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1054,axiom,
    ! [VarCurr] :
      ( v5891(VarCurr)
    <=> ( v5881(VarCurr,bitIndex0)
        & v5892(VarCurr) ) ) ).

fof(writeUnaryOperator_455,axiom,
    ! [VarCurr] :
      ( ~ v5892(VarCurr)
    <=> v5881(VarCurr,bitIndex1) ) ).

fof(addAssignment_1538,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5881(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1537,axiom,
    ! [VarCurr] :
      ( v5881(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_21,axiom,
    ! [VarCurr] :
      ( ~ v5867(VarCurr)
     => ( v5715(VarCurr,bitIndex7)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_19,axiom,
    ! [VarCurr] :
      ( v5867(VarCurr)
     => ( v5715(VarCurr,bitIndex7)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_183,axiom,
    ! [VarCurr] :
      ( v5867(VarCurr)
    <=> ( v5869(VarCurr,bitIndex6)
        | v5870(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1053,axiom,
    ! [VarCurr] :
      ( v5870(VarCurr)
    <=> ( v5871(VarCurr)
        & v5877(VarCurr) ) ) ).

fof(writeUnaryOperator_454,axiom,
    ! [VarCurr] :
      ( ~ v5877(VarCurr)
    <=> v5869(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_182,axiom,
    ! [VarCurr] :
      ( v5871(VarCurr)
    <=> ( v5869(VarCurr,bitIndex5)
        | v5872(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1052,axiom,
    ! [VarCurr] :
      ( v5872(VarCurr)
    <=> ( v5873(VarCurr)
        & v5876(VarCurr) ) ) ).

fof(writeUnaryOperator_453,axiom,
    ! [VarCurr] :
      ( ~ v5876(VarCurr)
    <=> v5869(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_181,axiom,
    ! [VarCurr] :
      ( v5873(VarCurr)
    <=> ( v5869(VarCurr,bitIndex4)
        | v5874(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_180,axiom,
    ! [VarCurr] :
      ( v5874(VarCurr)
    <=> ( v5869(VarCurr,bitIndex3)
        & v5875(VarCurr) ) ) ).

fof(writeUnaryOperator_452,axiom,
    ! [VarCurr] :
      ( ~ v5875(VarCurr)
    <=> v5869(VarCurr,bitIndex4) ) ).

fof(addAssignment_1536,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5869(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1535,axiom,
    ! [VarCurr] :
      ( v5869(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_20,axiom,
    ! [VarCurr] :
      ( ~ v5850(VarCurr)
     => ( v5715(VarCurr,bitIndex6)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_18,axiom,
    ! [VarCurr] :
      ( v5850(VarCurr)
     => ( v5715(VarCurr,bitIndex6)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_179,axiom,
    ! [VarCurr] :
      ( v5850(VarCurr)
    <=> ( v5852(VarCurr,bitIndex6)
        | v5853(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1051,axiom,
    ! [VarCurr] :
      ( v5853(VarCurr)
    <=> ( v5854(VarCurr)
        & v5865(VarCurr) ) ) ).

fof(writeUnaryOperator_451,axiom,
    ! [VarCurr] :
      ( ~ v5865(VarCurr)
    <=> v5852(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_178,axiom,
    ! [VarCurr] :
      ( v5854(VarCurr)
    <=> ( v5852(VarCurr,bitIndex5)
        | v5855(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1050,axiom,
    ! [VarCurr] :
      ( v5855(VarCurr)
    <=> ( v5856(VarCurr)
        & v5864(VarCurr) ) ) ).

fof(writeUnaryOperator_450,axiom,
    ! [VarCurr] :
      ( ~ v5864(VarCurr)
    <=> v5852(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_177,axiom,
    ! [VarCurr] :
      ( v5856(VarCurr)
    <=> ( v5852(VarCurr,bitIndex4)
        | v5857(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1049,axiom,
    ! [VarCurr] :
      ( v5857(VarCurr)
    <=> ( v5858(VarCurr)
        & v5863(VarCurr) ) ) ).

fof(writeUnaryOperator_449,axiom,
    ! [VarCurr] :
      ( ~ v5863(VarCurr)
    <=> v5852(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_176,axiom,
    ! [VarCurr] :
      ( v5858(VarCurr)
    <=> ( v5852(VarCurr,bitIndex3)
        | v5859(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1048,axiom,
    ! [VarCurr] :
      ( v5859(VarCurr)
    <=> ( v5860(VarCurr)
        & v5862(VarCurr) ) ) ).

fof(writeUnaryOperator_448,axiom,
    ! [VarCurr] :
      ( ~ v5862(VarCurr)
    <=> v5852(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_175,axiom,
    ! [VarCurr] :
      ( v5860(VarCurr)
    <=> ( v5861(VarCurr)
        & v5852(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_174,axiom,
    ! [VarCurr] :
      ( v5861(VarCurr)
    <=> ( v5852(VarCurr,bitIndex0)
        & v5852(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1534,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5852(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1533,axiom,
    ! [VarCurr] :
      ( v5852(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_19,axiom,
    ! [VarCurr] :
      ( ~ v5834(VarCurr)
     => ( v5715(VarCurr,bitIndex5)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_17,axiom,
    ! [VarCurr] :
      ( v5834(VarCurr)
     => ( v5715(VarCurr,bitIndex5)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_173,axiom,
    ! [VarCurr] :
      ( v5834(VarCurr)
    <=> ( v5836(VarCurr,bitIndex6)
        | v5837(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1047,axiom,
    ! [VarCurr] :
      ( v5837(VarCurr)
    <=> ( v5838(VarCurr)
        & v5848(VarCurr) ) ) ).

fof(writeUnaryOperator_447,axiom,
    ! [VarCurr] :
      ( ~ v5848(VarCurr)
    <=> v5836(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_172,axiom,
    ! [VarCurr] :
      ( v5838(VarCurr)
    <=> ( v5836(VarCurr,bitIndex5)
        | v5839(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1046,axiom,
    ! [VarCurr] :
      ( v5839(VarCurr)
    <=> ( v5840(VarCurr)
        & v5847(VarCurr) ) ) ).

fof(writeUnaryOperator_446,axiom,
    ! [VarCurr] :
      ( ~ v5847(VarCurr)
    <=> v5836(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_171,axiom,
    ! [VarCurr] :
      ( v5840(VarCurr)
    <=> ( v5836(VarCurr,bitIndex4)
        | v5841(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1045,axiom,
    ! [VarCurr] :
      ( v5841(VarCurr)
    <=> ( v5842(VarCurr)
        & v5846(VarCurr) ) ) ).

fof(writeUnaryOperator_445,axiom,
    ! [VarCurr] :
      ( ~ v5846(VarCurr)
    <=> v5836(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_170,axiom,
    ! [VarCurr] :
      ( v5842(VarCurr)
    <=> ( v5836(VarCurr,bitIndex3)
        | v5843(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1044,axiom,
    ! [VarCurr] :
      ( v5843(VarCurr)
    <=> ( v5844(VarCurr)
        & v5845(VarCurr) ) ) ).

fof(writeUnaryOperator_444,axiom,
    ! [VarCurr] :
      ( ~ v5845(VarCurr)
    <=> v5836(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_169,axiom,
    ! [VarCurr] :
      ( v5844(VarCurr)
    <=> ( v5836(VarCurr,bitIndex1)
        & v5836(VarCurr,bitIndex2) ) ) ).

fof(addAssignment_1532,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5836(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1531,axiom,
    ! [VarCurr] :
      ( v5836(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_18,axiom,
    ! [VarCurr] :
      ( ~ v5815(VarCurr)
     => ( v5715(VarCurr,bitIndex4)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_16,axiom,
    ! [VarCurr] :
      ( v5815(VarCurr)
     => ( v5715(VarCurr,bitIndex4)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_168,axiom,
    ! [VarCurr] :
      ( v5815(VarCurr)
    <=> ( v5817(VarCurr,bitIndex6)
        | v5818(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1043,axiom,
    ! [VarCurr] :
      ( v5818(VarCurr)
    <=> ( v5819(VarCurr)
        & v5832(VarCurr) ) ) ).

fof(writeUnaryOperator_443,axiom,
    ! [VarCurr] :
      ( ~ v5832(VarCurr)
    <=> v5817(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_167,axiom,
    ! [VarCurr] :
      ( v5819(VarCurr)
    <=> ( v5817(VarCurr,bitIndex5)
        | v5820(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1042,axiom,
    ! [VarCurr] :
      ( v5820(VarCurr)
    <=> ( v5821(VarCurr)
        & v5831(VarCurr) ) ) ).

fof(writeUnaryOperator_442,axiom,
    ! [VarCurr] :
      ( ~ v5831(VarCurr)
    <=> v5817(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_166,axiom,
    ! [VarCurr] :
      ( v5821(VarCurr)
    <=> ( v5817(VarCurr,bitIndex4)
        | v5822(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1041,axiom,
    ! [VarCurr] :
      ( v5822(VarCurr)
    <=> ( v5823(VarCurr)
        & v5830(VarCurr) ) ) ).

fof(writeUnaryOperator_441,axiom,
    ! [VarCurr] :
      ( ~ v5830(VarCurr)
    <=> v5817(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_165,axiom,
    ! [VarCurr] :
      ( v5823(VarCurr)
    <=> ( v5817(VarCurr,bitIndex3)
        | v5824(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1040,axiom,
    ! [VarCurr] :
      ( v5824(VarCurr)
    <=> ( v5825(VarCurr)
        & v5829(VarCurr) ) ) ).

fof(writeUnaryOperator_440,axiom,
    ! [VarCurr] :
      ( ~ v5829(VarCurr)
    <=> v5817(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_164,axiom,
    ! [VarCurr] :
      ( v5825(VarCurr)
    <=> ( v5826(VarCurr)
        & v5817(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_163,axiom,
    ! [VarCurr] :
      ( v5826(VarCurr)
    <=> ( v5817(VarCurr,bitIndex1)
        | v5827(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1039,axiom,
    ! [VarCurr] :
      ( v5827(VarCurr)
    <=> ( v5817(VarCurr,bitIndex0)
        & v5828(VarCurr) ) ) ).

fof(writeUnaryOperator_439,axiom,
    ! [VarCurr] :
      ( ~ v5828(VarCurr)
    <=> v5817(VarCurr,bitIndex1) ) ).

fof(addAssignment_1530,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5817(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1529,axiom,
    ! [VarCurr] :
      ( v5817(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_17,axiom,
    ! [VarCurr] :
      ( ~ v5800(VarCurr)
     => ( v5715(VarCurr,bitIndex3)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_15,axiom,
    ! [VarCurr] :
      ( v5800(VarCurr)
     => ( v5715(VarCurr,bitIndex3)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_162,axiom,
    ! [VarCurr] :
      ( v5800(VarCurr)
    <=> ( v5802(VarCurr,bitIndex6)
        | v5803(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1038,axiom,
    ! [VarCurr] :
      ( v5803(VarCurr)
    <=> ( v5804(VarCurr)
        & v5813(VarCurr) ) ) ).

fof(writeUnaryOperator_438,axiom,
    ! [VarCurr] :
      ( ~ v5813(VarCurr)
    <=> v5802(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_161,axiom,
    ! [VarCurr] :
      ( v5804(VarCurr)
    <=> ( v5802(VarCurr,bitIndex5)
        | v5805(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1037,axiom,
    ! [VarCurr] :
      ( v5805(VarCurr)
    <=> ( v5806(VarCurr)
        & v5812(VarCurr) ) ) ).

fof(writeUnaryOperator_437,axiom,
    ! [VarCurr] :
      ( ~ v5812(VarCurr)
    <=> v5802(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_160,axiom,
    ! [VarCurr] :
      ( v5806(VarCurr)
    <=> ( v5802(VarCurr,bitIndex4)
        | v5807(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1036,axiom,
    ! [VarCurr] :
      ( v5807(VarCurr)
    <=> ( v5808(VarCurr)
        & v5811(VarCurr) ) ) ).

fof(writeUnaryOperator_436,axiom,
    ! [VarCurr] :
      ( ~ v5811(VarCurr)
    <=> v5802(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_159,axiom,
    ! [VarCurr] :
      ( v5808(VarCurr)
    <=> ( v5802(VarCurr,bitIndex3)
        | v5809(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_158,axiom,
    ! [VarCurr] :
      ( v5809(VarCurr)
    <=> ( v5802(VarCurr,bitIndex2)
        & v5810(VarCurr) ) ) ).

fof(writeUnaryOperator_435,axiom,
    ! [VarCurr] :
      ( ~ v5810(VarCurr)
    <=> v5802(VarCurr,bitIndex3) ) ).

fof(addAssignment_1528,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5802(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1527,axiom,
    ! [VarCurr] :
      ( v5802(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_16,axiom,
    ! [VarCurr] :
      ( ~ v5781(VarCurr)
     => ( v5715(VarCurr,bitIndex2)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_14,axiom,
    ! [VarCurr] :
      ( v5781(VarCurr)
     => ( v5715(VarCurr,bitIndex2)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_157,axiom,
    ! [VarCurr] :
      ( v5781(VarCurr)
    <=> ( v5783(VarCurr,bitIndex6)
        | v5784(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1035,axiom,
    ! [VarCurr] :
      ( v5784(VarCurr)
    <=> ( v5785(VarCurr)
        & v5798(VarCurr) ) ) ).

fof(writeUnaryOperator_434,axiom,
    ! [VarCurr] :
      ( ~ v5798(VarCurr)
    <=> v5783(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_156,axiom,
    ! [VarCurr] :
      ( v5785(VarCurr)
    <=> ( v5783(VarCurr,bitIndex5)
        | v5786(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1034,axiom,
    ! [VarCurr] :
      ( v5786(VarCurr)
    <=> ( v5787(VarCurr)
        & v5797(VarCurr) ) ) ).

fof(writeUnaryOperator_433,axiom,
    ! [VarCurr] :
      ( ~ v5797(VarCurr)
    <=> v5783(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_155,axiom,
    ! [VarCurr] :
      ( v5787(VarCurr)
    <=> ( v5783(VarCurr,bitIndex4)
        | v5788(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1033,axiom,
    ! [VarCurr] :
      ( v5788(VarCurr)
    <=> ( v5789(VarCurr)
        & v5796(VarCurr) ) ) ).

fof(writeUnaryOperator_432,axiom,
    ! [VarCurr] :
      ( ~ v5796(VarCurr)
    <=> v5783(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_154,axiom,
    ! [VarCurr] :
      ( v5789(VarCurr)
    <=> ( v5783(VarCurr,bitIndex3)
        | v5790(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1032,axiom,
    ! [VarCurr] :
      ( v5790(VarCurr)
    <=> ( v5791(VarCurr)
        & v5795(VarCurr) ) ) ).

fof(writeUnaryOperator_431,axiom,
    ! [VarCurr] :
      ( ~ v5795(VarCurr)
    <=> v5783(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_153,axiom,
    ! [VarCurr] :
      ( v5791(VarCurr)
    <=> ( v5783(VarCurr,bitIndex2)
        | v5792(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1031,axiom,
    ! [VarCurr] :
      ( v5792(VarCurr)
    <=> ( v5793(VarCurr)
        & v5794(VarCurr) ) ) ).

fof(writeUnaryOperator_430,axiom,
    ! [VarCurr] :
      ( ~ v5794(VarCurr)
    <=> v5783(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges_152,axiom,
    ! [VarCurr] :
      ( v5793(VarCurr)
    <=> ( v5783(VarCurr,bitIndex0)
        & v5783(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1526,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5783(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1525,axiom,
    ! [VarCurr] :
      ( v5783(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_15,axiom,
    ! [VarCurr] :
      ( ~ v5763(VarCurr)
     => ( v5715(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_13,axiom,
    ! [VarCurr] :
      ( v5763(VarCurr)
     => ( v5715(VarCurr,bitIndex1)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_151,axiom,
    ! [VarCurr] :
      ( v5763(VarCurr)
    <=> ( v5765(VarCurr,bitIndex6)
        | v5766(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1030,axiom,
    ! [VarCurr] :
      ( v5766(VarCurr)
    <=> ( v5767(VarCurr)
        & v5779(VarCurr) ) ) ).

fof(writeUnaryOperator_429,axiom,
    ! [VarCurr] :
      ( ~ v5779(VarCurr)
    <=> v5765(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_150,axiom,
    ! [VarCurr] :
      ( v5767(VarCurr)
    <=> ( v5765(VarCurr,bitIndex5)
        | v5768(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1029,axiom,
    ! [VarCurr] :
      ( v5768(VarCurr)
    <=> ( v5769(VarCurr)
        & v5778(VarCurr) ) ) ).

fof(writeUnaryOperator_428,axiom,
    ! [VarCurr] :
      ( ~ v5778(VarCurr)
    <=> v5765(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_149,axiom,
    ! [VarCurr] :
      ( v5769(VarCurr)
    <=> ( v5765(VarCurr,bitIndex4)
        | v5770(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1028,axiom,
    ! [VarCurr] :
      ( v5770(VarCurr)
    <=> ( v5771(VarCurr)
        & v5777(VarCurr) ) ) ).

fof(writeUnaryOperator_427,axiom,
    ! [VarCurr] :
      ( ~ v5777(VarCurr)
    <=> v5765(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_148,axiom,
    ! [VarCurr] :
      ( v5771(VarCurr)
    <=> ( v5765(VarCurr,bitIndex3)
        | v5772(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1027,axiom,
    ! [VarCurr] :
      ( v5772(VarCurr)
    <=> ( v5773(VarCurr)
        & v5776(VarCurr) ) ) ).

fof(writeUnaryOperator_426,axiom,
    ! [VarCurr] :
      ( ~ v5776(VarCurr)
    <=> v5765(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_147,axiom,
    ! [VarCurr] :
      ( v5773(VarCurr)
    <=> ( v5765(VarCurr,bitIndex2)
        | v5774(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_146,axiom,
    ! [VarCurr] :
      ( v5774(VarCurr)
    <=> ( v5765(VarCurr,bitIndex1)
        & v5775(VarCurr) ) ) ).

fof(writeUnaryOperator_425,axiom,
    ! [VarCurr] :
      ( ~ v5775(VarCurr)
    <=> v5765(VarCurr,bitIndex2) ) ).

fof(addAssignment_1524,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5765(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1523,axiom,
    ! [VarCurr] :
      ( v5765(VarCurr,bitIndex6)
    <=> $false ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_155,axiom,
    ! [VarCurr] :
      ( ~ v5742(VarCurr)
     => ( v5715(VarCurr,bitIndex0)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_157,axiom,
    ! [VarCurr] :
      ( v5742(VarCurr)
     => ( v5715(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_145,axiom,
    ! [VarCurr] :
      ( v5742(VarCurr)
    <=> ( v5744(VarCurr,bitIndex6)
        | v5745(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1026,axiom,
    ! [VarCurr] :
      ( v5745(VarCurr)
    <=> ( v5746(VarCurr)
        & v5761(VarCurr) ) ) ).

fof(writeUnaryOperator_424,axiom,
    ! [VarCurr] :
      ( ~ v5761(VarCurr)
    <=> v5744(VarCurr,bitIndex6) ) ).

fof(writeBinaryOperatorShiftedRanges_144,axiom,
    ! [VarCurr] :
      ( v5746(VarCurr)
    <=> ( v5744(VarCurr,bitIndex5)
        | v5747(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1025,axiom,
    ! [VarCurr] :
      ( v5747(VarCurr)
    <=> ( v5748(VarCurr)
        & v5760(VarCurr) ) ) ).

fof(writeUnaryOperator_423,axiom,
    ! [VarCurr] :
      ( ~ v5760(VarCurr)
    <=> v5744(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_143,axiom,
    ! [VarCurr] :
      ( v5748(VarCurr)
    <=> ( v5744(VarCurr,bitIndex4)
        | v5749(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1024,axiom,
    ! [VarCurr] :
      ( v5749(VarCurr)
    <=> ( v5750(VarCurr)
        & v5759(VarCurr) ) ) ).

fof(writeUnaryOperator_422,axiom,
    ! [VarCurr] :
      ( ~ v5759(VarCurr)
    <=> v5744(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_142,axiom,
    ! [VarCurr] :
      ( v5750(VarCurr)
    <=> ( v5744(VarCurr,bitIndex3)
        | v5751(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1023,axiom,
    ! [VarCurr] :
      ( v5751(VarCurr)
    <=> ( v5752(VarCurr)
        & v5758(VarCurr) ) ) ).

fof(writeUnaryOperator_421,axiom,
    ! [VarCurr] :
      ( ~ v5758(VarCurr)
    <=> v5744(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_141,axiom,
    ! [VarCurr] :
      ( v5752(VarCurr)
    <=> ( v5744(VarCurr,bitIndex2)
        | v5753(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1022,axiom,
    ! [VarCurr] :
      ( v5753(VarCurr)
    <=> ( v5754(VarCurr)
        & v5757(VarCurr) ) ) ).

fof(writeUnaryOperator_420,axiom,
    ! [VarCurr] :
      ( ~ v5757(VarCurr)
    <=> v5744(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges_140,axiom,
    ! [VarCurr] :
      ( v5754(VarCurr)
    <=> ( v5744(VarCurr,bitIndex1)
        | v5755(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1021,axiom,
    ! [VarCurr] :
      ( v5755(VarCurr)
    <=> ( v5744(VarCurr,bitIndex0)
        & v5756(VarCurr) ) ) ).

fof(writeUnaryOperator_419,axiom,
    ! [VarCurr] :
      ( ~ v5756(VarCurr)
    <=> v5744(VarCurr,bitIndex1) ) ).

fof(addAssignment_1522,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v5744(VarCurr,B)
      <=> v5635(VarCurr,B) ) ) ).

fof(addAssignment_1521,axiom,
    ! [VarCurr] :
      ( v5744(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addCaseBooleanConditionEqualRanges1_101,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5676(VarNext)
       => ( v5671(VarNext)
        <=> v5671(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_112,axiom,
    ! [VarNext] :
      ( v5676(VarNext)
     => ( v5671(VarNext)
      <=> v5711(VarNext) ) ) ).

fof(addAssignment_1520,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5711(VarNext)
      <=> v5709(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_154,axiom,
    ! [VarCurr] :
      ( ~ v5708(VarCurr)
     => ( v5709(VarCurr)
      <=> v5673(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_156,axiom,
    ! [VarCurr] :
      ( v5708(VarCurr)
     => ( v5709(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1020,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5676(VarNext)
      <=> ( v5677(VarNext)
          & v5684(VarNext) ) ) ) ).

fof(addAssignment_1519,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5684(VarNext)
      <=> v5682(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1019,axiom,
    ! [VarCurr] :
      ( v5682(VarCurr)
    <=> ( v5685(VarCurr)
        | v5708(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_385,axiom,
    ! [VarCurr] :
      ( v5708(VarCurr)
    <=> ( v4952(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1018,axiom,
    ! [VarCurr] :
      ( v5685(VarCurr)
    <=> ( v5686(VarCurr)
        & v5705(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1017,axiom,
    ! [VarCurr] :
      ( v5705(VarCurr)
    <=> ( v5706(VarCurr)
        | v5703(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1016,axiom,
    ! [VarCurr] :
      ( v5706(VarCurr)
    <=> ( v5707(VarCurr)
        | v5699(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1015,axiom,
    ! [VarCurr] :
      ( v5707(VarCurr)
    <=> ( v5691(VarCurr)
        | v5695(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1014,axiom,
    ! [VarCurr] :
      ( v5686(VarCurr)
    <=> ( v5687(VarCurr)
        & v5701(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1013,axiom,
    ! [VarCurr] :
      ( v5701(VarCurr)
    <=> ( v5143(VarCurr)
        | v5702(VarCurr) ) ) ).

fof(writeUnaryOperator_418,axiom,
    ! [VarCurr] :
      ( ~ v5702(VarCurr)
    <=> v5703(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_384,axiom,
    ! [VarCurr] :
      ( v5703(VarCurr)
    <=> ( ( v5704(VarCurr,bitIndex3)
        <=> $false )
        & ( v5704(VarCurr,bitIndex2)
        <=> $true )
        & ( v5704(VarCurr,bitIndex1)
        <=> $true )
        & ( v5704(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1518,axiom,
    ! [VarCurr] :
      ( v5704(VarCurr,bitIndex0)
    <=> v5163(VarCurr) ) ).

fof(addAssignment_1517,axiom,
    ! [VarCurr] :
      ( ( v5704(VarCurr,bitIndex3)
      <=> v4958(VarCurr,bitIndex2) )
      & ( v5704(VarCurr,bitIndex2)
      <=> v4958(VarCurr,bitIndex1) )
      & ( v5704(VarCurr,bitIndex1)
      <=> v4958(VarCurr,bitIndex0) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1012,axiom,
    ! [VarCurr] :
      ( v5687(VarCurr)
    <=> ( v5688(VarCurr)
        & v5697(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1011,axiom,
    ! [VarCurr] :
      ( v5697(VarCurr)
    <=> ( v5143(VarCurr)
        | v5698(VarCurr) ) ) ).

fof(writeUnaryOperator_417,axiom,
    ! [VarCurr] :
      ( ~ v5698(VarCurr)
    <=> v5699(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_383,axiom,
    ! [VarCurr] :
      ( v5699(VarCurr)
    <=> ( ( v5700(VarCurr,bitIndex3)
        <=> $false )
        & ( v5700(VarCurr,bitIndex2)
        <=> $true )
        & ( v5700(VarCurr,bitIndex1)
        <=> $false )
        & ( v5700(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1516,axiom,
    ! [VarCurr] :
      ( v5700(VarCurr,bitIndex0)
    <=> v5163(VarCurr) ) ).

fof(addAssignment_1515,axiom,
    ! [VarCurr] :
      ( ( v5700(VarCurr,bitIndex3)
      <=> v4958(VarCurr,bitIndex2) )
      & ( v5700(VarCurr,bitIndex2)
      <=> v4958(VarCurr,bitIndex1) )
      & ( v5700(VarCurr,bitIndex1)
      <=> v4958(VarCurr,bitIndex0) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1010,axiom,
    ! [VarCurr] :
      ( v5688(VarCurr)
    <=> ( v5689(VarCurr)
        & v5693(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1009,axiom,
    ! [VarCurr] :
      ( v5693(VarCurr)
    <=> ( v5143(VarCurr)
        | v5694(VarCurr) ) ) ).

fof(writeUnaryOperator_416,axiom,
    ! [VarCurr] :
      ( ~ v5694(VarCurr)
    <=> v5695(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_382,axiom,
    ! [VarCurr] :
      ( v5695(VarCurr)
    <=> ( ( v5696(VarCurr,bitIndex3)
        <=> $false )
        & ( v5696(VarCurr,bitIndex2)
        <=> $true )
        & ( v5696(VarCurr,bitIndex1)
        <=> $true )
        & ( v5696(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1514,axiom,
    ! [VarCurr] :
      ( v5696(VarCurr,bitIndex0)
    <=> v5163(VarCurr) ) ).

fof(addAssignment_1513,axiom,
    ! [VarCurr] :
      ( ( v5696(VarCurr,bitIndex3)
      <=> v4958(VarCurr,bitIndex2) )
      & ( v5696(VarCurr,bitIndex2)
      <=> v4958(VarCurr,bitIndex1) )
      & ( v5696(VarCurr,bitIndex1)
      <=> v4958(VarCurr,bitIndex0) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1008,axiom,
    ! [VarCurr] :
      ( v5689(VarCurr)
    <=> ( v5143(VarCurr)
        | v5690(VarCurr) ) ) ).

fof(writeUnaryOperator_415,axiom,
    ! [VarCurr] :
      ( ~ v5690(VarCurr)
    <=> v5691(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_381,axiom,
    ! [VarCurr] :
      ( v5691(VarCurr)
    <=> ( ( v5692(VarCurr,bitIndex3)
        <=> $false )
        & ( v5692(VarCurr,bitIndex2)
        <=> $true )
        & ( v5692(VarCurr,bitIndex1)
        <=> $false )
        & ( v5692(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1512,axiom,
    ! [VarCurr] :
      ( v5692(VarCurr,bitIndex0)
    <=> v5163(VarCurr) ) ).

fof(addAssignment_1511,axiom,
    ! [VarCurr] :
      ( ( v5692(VarCurr,bitIndex3)
      <=> v4958(VarCurr,bitIndex2) )
      & ( v5692(VarCurr,bitIndex2)
      <=> v4958(VarCurr,bitIndex1) )
      & ( v5692(VarCurr,bitIndex1)
      <=> v4958(VarCurr,bitIndex0) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1007,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5677(VarNext)
      <=> ( v5678(VarNext)
          & v4988(VarNext) ) ) ) ).

fof(writeUnaryOperator_414,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5678(VarNext)
      <=> v4995(VarNext) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_100,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5640(VarNext)
       => ! [B] :
            ( range_5_0(B)
           => ( v5635(VarNext,B)
            <=> v5635(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_111,axiom,
    ! [VarNext] :
      ( v5640(VarNext)
     => ! [B] :
          ( range_5_0(B)
         => ( v5635(VarNext,B)
          <=> v5666(VarNext,B) ) ) ) ).

fof(addAssignment_1510,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_5_0(B)
         => ( v5666(VarNext,B)
          <=> v5664(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_130,axiom,
    ! [VarCurr] :
      ( ~ v5650(VarCurr)
     => ! [B] :
          ( range_5_0(B)
         => ( v5664(VarCurr,B)
          <=> v5667(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_124,axiom,
    ! [VarCurr] :
      ( v5650(VarCurr)
     => ! [B] :
          ( range_5_0(B)
         => ( v5664(VarCurr,B)
          <=> b000001(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_129,axiom,
    ! [VarCurr] :
      ( ~ v5653(VarCurr)
     => ! [B] :
          ( range_5_0(B)
         => ( v5667(VarCurr,B)
          <=> b000001(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_123,axiom,
    ! [VarCurr] :
      ( v5653(VarCurr)
     => ! [B] :
          ( range_5_0(B)
         => ( v5667(VarCurr,B)
          <=> v5637(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1006,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5640(VarNext)
      <=> ( v5641(VarNext)
          & v5648(VarNext) ) ) ) ).

fof(addAssignment_1509,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5648(VarNext)
      <=> v5646(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1005,axiom,
    ! [VarCurr] :
      ( v5646(VarCurr)
    <=> ( v5649(VarCurr)
        & v5660(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1004,axiom,
    ! [VarCurr] :
      ( v5660(VarCurr)
    <=> ( v5661(VarCurr)
        | v5650(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1003,axiom,
    ! [VarCurr] :
      ( v5661(VarCurr)
    <=> ( v5662(VarCurr)
        & v5663(VarCurr) ) ) ).

fof(writeUnaryOperator_413,axiom,
    ! [VarCurr] :
      ( ~ v5663(VarCurr)
    <=> v5658(VarCurr) ) ).

fof(writeUnaryOperator_412,axiom,
    ! [VarCurr] :
      ( ~ v5662(VarCurr)
    <=> v5657(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1002,axiom,
    ! [VarCurr] :
      ( v5649(VarCurr)
    <=> ( v5650(VarCurr)
        | v5651(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1001,axiom,
    ! [VarCurr] :
      ( v5651(VarCurr)
    <=> ( v5652(VarCurr)
        & v5659(VarCurr) ) ) ).

fof(writeUnaryOperator_411,axiom,
    ! [VarCurr] :
      ( ~ v5659(VarCurr)
    <=> v5650(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1000,axiom,
    ! [VarCurr] :
      ( v5652(VarCurr)
    <=> ( v5653(VarCurr)
        | v5654(VarCurr) ) ) ).

fof(writeUnaryOperator_410,axiom,
    ! [VarCurr] :
      ( ~ v5654(VarCurr)
    <=> v5655(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_999,axiom,
    ! [VarCurr] :
      ( v5655(VarCurr)
    <=> ( v5656(VarCurr)
        | v5658(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_380,axiom,
    ! [VarCurr] :
      ( v5658(VarCurr)
    <=> ( ( v4958(VarCurr,bitIndex2)
        <=> $false )
        & ( v4958(VarCurr,bitIndex1)
        <=> $true )
        & ( v4958(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_998,axiom,
    ! [VarCurr] :
      ( v5656(VarCurr)
    <=> ( v5653(VarCurr)
        | v5657(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_379,axiom,
    ! [VarCurr] :
      ( v5657(VarCurr)
    <=> ( ( v4958(VarCurr,bitIndex2)
        <=> $false )
        & ( v4958(VarCurr,bitIndex1)
        <=> $true )
        & ( v4958(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_378,axiom,
    ! [VarCurr] :
      ( v5653(VarCurr)
    <=> ( ( v4958(VarCurr,bitIndex2)
        <=> $false )
        & ( v4958(VarCurr,bitIndex1)
        <=> $false )
        & ( v4958(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_377,axiom,
    ! [VarCurr] :
      ( v5650(VarCurr)
    <=> ( v4952(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_997,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5641(VarNext)
      <=> ( v5642(VarNext)
          & v4988(VarNext) ) ) ) ).

fof(writeUnaryOperator_409,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5642(VarNext)
      <=> v4995(VarNext) ) ) ).

fof(addAssignment_1508,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v5575(VarCurr,B)
      <=> v5577(VarCurr,B) ) ) ).

fof(addAssignment_1507,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v5577(VarCurr,B)
      <=> v5579(VarCurr,B) ) ) ).

fof(addAssignment_1506,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v5579(VarCurr,B)
      <=> v5581(VarCurr,B) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_99,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5594(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v5581(VarNext,B)
            <=> v5581(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_110,axiom,
    ! [VarNext] :
      ( v5594(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v5581(VarNext,B)
          <=> v5605(VarNext,B) ) ) ) ).

fof(addAssignment_1505,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v5605(VarNext,B)
          <=> v5603(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_153,axiom,
    ! [VarCurr] :
      ( ~ v5250(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v5603(VarCurr,B)
          <=> v5583(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_155,axiom,
    ! [VarCurr] :
      ( v5250(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v5603(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_996,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5594(VarNext)
      <=> ( v5595(VarNext)
          & v5602(VarNext) ) ) ) ).

fof(addAssignment_1504,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5602(VarNext)
      <=> v5600(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_995,axiom,
    ! [VarCurr] :
      ( v5600(VarCurr)
    <=> ( v5169(VarCurr)
        | v5250(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_994,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5595(VarNext)
      <=> ( v5597(VarNext)
          & v4988(VarNext) ) ) ) ).

fof(writeUnaryOperator_408,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5597(VarNext)
      <=> v4995(VarNext) ) ) ).

fof(addAssignment_1503,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v5583(VarCurr,B)
      <=> v5585(VarCurr,B) ) ) ).

fof(addAssignment_1502,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v5585(VarCurr,B)
      <=> v5587(VarCurr,B) ) ) ).

fof(addAssignment_1501,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v5587(VarCurr,B)
      <=> v5589(VarCurr,B) ) ) ).

fof(addAssignment_1500,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v5589(VarCurr,B)
      <=> v5591(VarCurr,B) ) ) ).

fof(addAssignment_1499,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v5567(VarCurr,B)
      <=> v5569(VarCurr,B) ) ) ).

fof(addAssignment_1498,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v5569(VarCurr,B)
      <=> v5571(VarCurr,B) ) ) ).

fof(addAssignment_1497,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v5571(VarCurr,B)
      <=> v5573(VarCurr,B) ) ) ).

fof(addAssignment_1496,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v5573(VarCurr,B)
      <=> $false ) ) ).

fof(addAssignment_1495,axiom,
    ! [VarCurr] :
      ( v5319(VarCurr)
    <=> v5321(VarCurr) ) ).

fof(addAssignment_1494,axiom,
    ! [VarCurr] :
      ( v5321(VarCurr)
    <=> v5323(VarCurr) ) ).

fof(addAssignment_1493,axiom,
    ! [VarCurr] :
      ( v5323(VarCurr)
    <=> v5325(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_98,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5555(VarNext)
       => ( v5325(VarNext)
        <=> v5325(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_109,axiom,
    ! [VarNext] :
      ( v5555(VarNext)
     => ( v5325(VarNext)
      <=> v5563(VarNext) ) ) ).

fof(addAssignment_1492,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5563(VarNext)
      <=> v5561(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_152,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ( v5561(VarCurr)
      <=> v5327(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_154,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ( v5561(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_993,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5555(VarNext)
      <=> v5556(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_992,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5556(VarNext)
      <=> ( v5558(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_407,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5558(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_55,axiom,
    ! [VarCurr] :
      ( ( ~ v5552(VarCurr)
        & ~ v5385(VarCurr) )
     => ( v5327(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_128,axiom,
    ! [VarCurr] :
      ( v5385(VarCurr)
     => ( v5327(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_122,axiom,
    ! [VarCurr] :
      ( v5552(VarCurr)
     => ( v5327(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_991,axiom,
    ! [VarCurr] :
      ( v5552(VarCurr)
    <=> ( v5377(VarCurr)
        | v5381(VarCurr) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_97,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5539(VarNext)
       => ! [B] :
            ( range_1_0(B)
           => ( v5329(VarNext,B)
            <=> v5329(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_108,axiom,
    ! [VarNext] :
      ( v5539(VarNext)
     => ! [B] :
          ( range_1_0(B)
         => ( v5329(VarNext,B)
          <=> v5547(VarNext,B) ) ) ) ).

fof(addAssignment_1491,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_1_0(B)
         => ( v5547(VarNext,B)
          <=> v5545(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_151,axiom,
    ! [VarCurr] :
      ( ~ v5548(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5545(VarCurr,B)
          <=> v5331(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_153,axiom,
    ! [VarCurr] :
      ( v5548(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5545(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_376,axiom,
    ! [VarCurr] :
      ( v5548(VarCurr)
    <=> ( v51(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_990,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5539(VarNext)
      <=> v5540(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_989,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5540(VarNext)
      <=> ( v5541(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_406,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5541(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_25,axiom,
    ! [VarCurr] :
      ( ( ~ v5377(VarCurr)
        & ~ v5381(VarCurr)
        & ~ v5385(VarCurr) )
     => ! [B] :
          ( range_1_0(B)
         => ( v5331(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_54,axiom,
    ! [VarCurr] :
      ( v5385(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5331(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_127,axiom,
    ! [VarCurr] :
      ( v5381(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5331(VarCurr,B)
          <=> v5536(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_121,axiom,
    ! [VarCurr] :
      ( v5377(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5331(VarCurr,B)
          <=> v5535(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_126,axiom,
    ! [VarCurr] :
      ( ~ v5383(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5536(VarCurr,B)
          <=> b10(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_120,axiom,
    ! [VarCurr] :
      ( v5383(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5536(VarCurr,B)
          <=> b01(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_125,axiom,
    ! [VarCurr] :
      ( ~ v5379(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5535(VarCurr,B)
          <=> b01(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_119,axiom,
    ! [VarCurr] :
      ( v5379(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5535(VarCurr,B)
          <=> $false ) ) ) ).

fof(addAssignment_1490,axiom,
    ! [VarCurr] :
      ( v5355(VarCurr)
    <=> v5357(VarCurr) ) ).

fof(addAssignment_1489,axiom,
    ! [VarCurr] :
      ( v5357(VarCurr)
    <=> v5359(VarCurr) ) ).

fof(addAssignment_1488,axiom,
    ! [VarCurr] :
      ( v5359(VarCurr)
    <=> v5361(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_96,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5523(VarNext)
       => ( v5361(VarNext)
        <=> v5361(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_107,axiom,
    ! [VarNext] :
      ( v5523(VarNext)
     => ( v5361(VarNext)
      <=> v5531(VarNext) ) ) ).

fof(addAssignment_1487,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5531(VarNext)
      <=> v5529(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_150,axiom,
    ! [VarCurr] :
      ( ~ v5120(VarCurr)
     => ( v5529(VarCurr)
      <=> v5363(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_152,axiom,
    ! [VarCurr] :
      ( v5120(VarCurr)
     => ( v5529(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_988,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5523(VarNext)
      <=> v5524(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_987,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5524(VarNext)
      <=> ( v5526(VarNext)
          & v4937(VarNext) ) ) ) ).

fof(writeUnaryOperator_405,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5526(VarNext)
      <=> v5113(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_53,axiom,
    ! [VarCurr] :
      ( ( ~ v5500(VarCurr)
        & ~ v5503(VarCurr) )
     => ( v5363(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_124,axiom,
    ! [VarCurr] :
      ( v5503(VarCurr)
     => ( v5363(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_118,axiom,
    ! [VarCurr] :
      ( v5500(VarCurr)
     => ( v5363(VarCurr)
      <=> v5519(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_149,axiom,
    ! [VarCurr] :
      ( ~ v5369(VarCurr)
     => ( v5519(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_151,axiom,
    ! [VarCurr] :
      ( v5369(VarCurr)
     => ( v5519(VarCurr)
      <=> v5520(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_148,axiom,
    ! [VarCurr] :
      ( ~ v5401(VarCurr)
     => ( v5520(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_150,axiom,
    ! [VarCurr] :
      ( v5401(VarCurr)
     => ( v5520(VarCurr)
      <=> $false ) ) ).

fof(addCaseBooleanConditionEqualRanges1_95,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5506(VarNext)
       => ! [B] :
            ( range_1_0(B)
           => ( v5365(VarNext,B)
            <=> v5365(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_106,axiom,
    ! [VarNext] :
      ( v5506(VarNext)
     => ! [B] :
          ( range_1_0(B)
         => ( v5365(VarNext,B)
          <=> v5514(VarNext,B) ) ) ) ).

fof(addAssignment_1486,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_1_0(B)
         => ( v5514(VarNext,B)
          <=> v5512(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_147,axiom,
    ! [VarCurr] :
      ( ~ v5515(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5512(VarCurr,B)
          <=> v5367(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_149,axiom,
    ! [VarCurr] :
      ( v5515(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5512(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_375,axiom,
    ! [VarCurr] :
      ( v5515(VarCurr)
    <=> ( v4942(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_986,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5506(VarNext)
      <=> v5507(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_985,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5507(VarNext)
      <=> ( v5508(VarNext)
          & v4937(VarNext) ) ) ) ).

fof(writeUnaryOperator_404,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5508(VarNext)
      <=> v5113(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_52,axiom,
    ! [VarCurr] :
      ( ( ~ v5500(VarCurr)
        & ~ v5503(VarCurr) )
     => ! [B] :
          ( range_1_0(B)
         => ( v5367(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_123,axiom,
    ! [VarCurr] :
      ( v5503(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5367(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_117,axiom,
    ! [VarCurr] :
      ( v5500(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5367(VarCurr,B)
          <=> v5501(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_374,axiom,
    ! [VarCurr] :
      ( v5503(VarCurr)
    <=> ( ( v5365(VarCurr,bitIndex1)
        <=> $false )
        & ( v5365(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_146,axiom,
    ! [VarCurr] :
      ( ~ v5369(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5501(VarCurr,B)
          <=> $false ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_148,axiom,
    ! [VarCurr] :
      ( v5369(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5501(VarCurr,B)
          <=> v5502(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_145,axiom,
    ! [VarCurr] :
      ( ~ v5401(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5502(VarCurr,B)
          <=> b01(B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_147,axiom,
    ! [VarCurr] :
      ( v5401(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v5502(VarCurr,B)
          <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_373,axiom,
    ! [VarCurr] :
      ( v5500(VarCurr)
    <=> ( ( v5365(VarCurr,bitIndex1)
        <=> $false )
        & ( v5365(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1485,axiom,
    ! [VarCurr] :
      ( v5401(VarCurr)
    <=> v5403(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_94,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5477(VarNext)
       => ( v5403(VarNext)
        <=> v5403(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_105,axiom,
    ! [VarNext] :
      ( v5477(VarNext)
     => ( v5403(VarNext)
      <=> v5495(VarNext) ) ) ).

fof(addAssignment_1484,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5495(VarNext)
      <=> v5493(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_144,axiom,
    ! [VarCurr] :
      ( ~ v5492(VarCurr)
     => ( v5493(VarCurr)
      <=> v5496(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_146,axiom,
    ! [VarCurr] :
      ( v5492(VarCurr)
     => ( v5493(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_143,axiom,
    ! [VarCurr] :
      ( ~ v5407(VarCurr)
     => ( v5496(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_145,axiom,
    ! [VarCurr] :
      ( v5407(VarCurr)
     => ( v5496(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_984,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5477(VarNext)
      <=> ( v5478(VarNext)
          & v5487(VarNext) ) ) ) ).

fof(addAssignment_1483,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5487(VarNext)
      <=> v5485(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_983,axiom,
    ! [VarCurr] :
      ( v5485(VarCurr)
    <=> ( v5488(VarCurr)
        | v5492(VarCurr) ) ) ).

fof(writeUnaryOperator_403,axiom,
    ! [VarCurr] :
      ( ~ v5492(VarCurr)
    <=> v5405(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_982,axiom,
    ! [VarCurr] :
      ( v5488(VarCurr)
    <=> ( v5489(VarCurr)
        | v5407(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_981,axiom,
    ! [VarCurr] :
      ( v5489(VarCurr)
    <=> ( v5490(VarCurr)
        & v5491(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_372,axiom,
    ! [VarCurr] :
      ( v5491(VarCurr)
    <=> ( v5472(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_371,axiom,
    ! [VarCurr] :
      ( v5490(VarCurr)
    <=> ( v5470(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_980,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5478(VarNext)
      <=> ( v5479(VarNext)
          & v5474(VarNext) ) ) ) ).

fof(writeUnaryOperator_402,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5479(VarNext)
      <=> v5481(VarNext) ) ) ).

fof(addAssignment_1482,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5481(VarNext)
      <=> v5474(VarCurr) ) ) ).

fof(addAssignment_1481,axiom,
    ! [VarCurr] :
      ( v5474(VarCurr)
    <=> v4937(VarCurr) ) ).

fof(addAssignment_1480,axiom,
    ! [VarCurr] :
      ( v5470(VarCurr)
    <=> v5361(VarCurr) ) ).

fof(addAssignmentInitValueVector_23,axiom,
    ( v5361(constB0)
  <=> $false ) ).

fof(addAssignment_1479,axiom,
    ! [VarCurr] :
      ( v5407(VarCurr)
    <=> v5409(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_142,axiom,
    ! [VarCurr] :
      ( ~ v5411(VarCurr)
     => ( v5409(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_144,axiom,
    ! [VarCurr] :
      ( v5411(VarCurr)
     => ( v5409(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorShiftedRanges_139,axiom,
    ! [VarCurr] :
      ( v5411(VarCurr)
    <=> ( v5413(VarCurr)
        & v5432(VarCurr,bitIndex4) ) ) ).

fof(addAssignment_1478,axiom,
    ! [VarCurr] :
      ( v5432(VarCurr,bitIndex4)
    <=> v5434(VarCurr,bitIndex4) ) ).

fof(addAssignment_1477,axiom,
    ! [VarCurr] :
      ( v5434(VarCurr,bitIndex4)
    <=> v5436(VarCurr,bitIndex4) ) ).

fof(addAssignment_1476,axiom,
    ! [VarNext] :
      ( v5436(VarNext,bitIndex4)
    <=> v5441(VarNext,bitIndex4) ) ).

fof(addCaseBooleanConditionEqualRanges1_93,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5442(VarNext)
       => ! [B] :
            ( range_16_0(B)
           => ( v5441(VarNext,B)
            <=> v5436(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_104,axiom,
    ! [VarNext] :
      ( v5442(VarNext)
     => ! [B] :
          ( range_16_0(B)
         => ( v5441(VarNext,B)
          <=> v5453(VarNext,B) ) ) ) ).

fof(addAssignment_1475,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_16_0(B)
         => ( v5453(VarNext,B)
          <=> v5451(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_141,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ! [B] :
          ( range_16_0(B)
         => ( v5451(VarCurr,B)
          <=> v5454(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_143,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ! [B] :
          ( range_16_0(B)
         => ( v5451(VarCurr,B)
          <=> $false ) ) ) ).

fof(range_axiom_38,axiom,
    ! [B] :
      ( range_16_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B
        | bitIndex11 = B
        | bitIndex12 = B
        | bitIndex13 = B
        | bitIndex14 = B
        | bitIndex15 = B
        | bitIndex16 = B ) ) ).

fof(bitBlastConstant_414,axiom,
    ~ b00000000000000000(bitIndex16) ).

fof(bitBlastConstant_413,axiom,
    ~ b00000000000000000(bitIndex15) ).

fof(bitBlastConstant_412,axiom,
    ~ b00000000000000000(bitIndex14) ).

fof(bitBlastConstant_411,axiom,
    ~ b00000000000000000(bitIndex13) ).

fof(bitBlastConstant_410,axiom,
    ~ b00000000000000000(bitIndex12) ).

fof(bitBlastConstant_409,axiom,
    ~ b00000000000000000(bitIndex11) ).

fof(bitBlastConstant_408,axiom,
    ~ b00000000000000000(bitIndex10) ).

fof(bitBlastConstant_407,axiom,
    ~ b00000000000000000(bitIndex9) ).

fof(bitBlastConstant_406,axiom,
    ~ b00000000000000000(bitIndex8) ).

fof(bitBlastConstant_405,axiom,
    ~ b00000000000000000(bitIndex7) ).

fof(bitBlastConstant_404,axiom,
    ~ b00000000000000000(bitIndex6) ).

fof(bitBlastConstant_403,axiom,
    ~ b00000000000000000(bitIndex5) ).

fof(bitBlastConstant_402,axiom,
    ~ b00000000000000000(bitIndex4) ).

fof(bitBlastConstant_401,axiom,
    ~ b00000000000000000(bitIndex3) ).

fof(bitBlastConstant_400,axiom,
    ~ b00000000000000000(bitIndex2) ).

fof(bitBlastConstant_399,axiom,
    ~ b00000000000000000(bitIndex1) ).

fof(bitBlastConstant_398,axiom,
    ~ b00000000000000000(bitIndex0) ).

fof(addAssignment_1474,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v5454(VarCurr,B)
      <=> v5463(VarCurr,B) ) ) ).

fof(addAssignment_1473,axiom,
    ! [VarCurr] :
      ( v5454(VarCurr,bitIndex4)
    <=> v5439(VarCurr) ) ).

fof(addAssignment_1472,axiom,
    ! [VarCurr] :
      ( ( v5454(VarCurr,bitIndex9)
      <=> v5461(VarCurr,bitIndex4) )
      & ( v5454(VarCurr,bitIndex8)
      <=> v5461(VarCurr,bitIndex3) )
      & ( v5454(VarCurr,bitIndex7)
      <=> v5461(VarCurr,bitIndex2) )
      & ( v5454(VarCurr,bitIndex6)
      <=> v5461(VarCurr,bitIndex1) )
      & ( v5454(VarCurr,bitIndex5)
      <=> v5461(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1471,axiom,
    ! [VarCurr] :
      ( v5454(VarCurr,bitIndex10)
    <=> v5459(VarCurr) ) ).

fof(addAssignment_1470,axiom,
    ! [VarCurr] :
      ( ( v5454(VarCurr,bitIndex15)
      <=> v5457(VarCurr,bitIndex4) )
      & ( v5454(VarCurr,bitIndex14)
      <=> v5457(VarCurr,bitIndex3) )
      & ( v5454(VarCurr,bitIndex13)
      <=> v5457(VarCurr,bitIndex2) )
      & ( v5454(VarCurr,bitIndex12)
      <=> v5457(VarCurr,bitIndex1) )
      & ( v5454(VarCurr,bitIndex11)
      <=> v5457(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1469,axiom,
    ! [VarCurr] :
      ( v5454(VarCurr,bitIndex16)
    <=> v5455(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_979,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5442(VarNext)
      <=> ( v5443(VarNext)
          & v5450(VarNext) ) ) ) ).

fof(addAssignment_1468,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5450(VarNext)
      <=> v5448(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_978,axiom,
    ! [VarCurr] :
      ( v5448(VarCurr)
    <=> ( v49(VarCurr)
        | v5397(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_977,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5443(VarNext)
      <=> ( v5445(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_401,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5445(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignment_1467,axiom,
    ! [VarCurr] :
      ( v5413(VarCurr)
    <=> v5415(VarCurr) ) ).

fof(addAssignment_1466,axiom,
    ! [VarCurr] :
      ( v5415(VarCurr)
    <=> v5417(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_92,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5420(VarNext)
       => ( v5417(VarNext)
        <=> v5417(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_103,axiom,
    ! [VarNext] :
      ( v5420(VarNext)
     => ( v5417(VarNext)
      <=> v5428(VarNext) ) ) ).

fof(addAssignment_1465,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5428(VarNext)
      <=> v5426(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_140,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ( v5426(VarCurr)
      <=> v49(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_142,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ( v5426(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_976,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5420(VarNext)
      <=> v5421(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_975,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5421(VarNext)
      <=> ( v5423(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_400,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5423(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignment_1464,axiom,
    ! [VarCurr] :
      ( v5405(VarCurr)
    <=> v4942(VarCurr) ) ).

fof(addAssignment_1463,axiom,
    ! [VarCurr] :
      ( v5369(VarCurr)
    <=> v5371(VarCurr) ) ).

fof(addAssignment_1462,axiom,
    ! [VarCurr] :
      ( v5371(VarCurr)
    <=> v5373(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_91,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5388(VarNext)
       => ( v5373(VarNext)
        <=> v5373(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_102,axiom,
    ! [VarNext] :
      ( v5388(VarNext)
     => ( v5373(VarNext)
      <=> v5396(VarNext) ) ) ).

fof(addAssignment_1461,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5396(VarNext)
      <=> v5394(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_139,axiom,
    ! [VarCurr] :
      ( ~ v5397(VarCurr)
     => ( v5394(VarCurr)
      <=> v5375(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_141,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
     => ( v5394(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_370,axiom,
    ! [VarCurr] :
      ( v5397(VarCurr)
    <=> ( v51(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_974,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5388(VarNext)
      <=> v5389(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_973,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5389(VarNext)
      <=> ( v5390(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_399,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5390(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_24,axiom,
    ! [VarCurr] :
      ( ( ~ v5377(VarCurr)
        & ~ v5381(VarCurr)
        & ~ v5385(VarCurr) )
     => ( v5375(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_51,axiom,
    ! [VarCurr] :
      ( v5385(VarCurr)
     => ( v5375(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_122,axiom,
    ! [VarCurr] :
      ( v5381(VarCurr)
     => ( v5375(VarCurr)
      <=> v5382(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_116,axiom,
    ! [VarCurr] :
      ( v5377(VarCurr)
     => ( v5375(VarCurr)
      <=> v5378(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_369,axiom,
    ! [VarCurr] :
      ( v5385(VarCurr)
    <=> ( ( v5329(VarCurr,bitIndex1)
        <=> $true )
        & ( v5329(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_121,axiom,
    ! [VarCurr] :
      ( ~ v5383(VarCurr)
     => ( v5382(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_115,axiom,
    ! [VarCurr] :
      ( v5383(VarCurr)
     => ( v5382(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_368,axiom,
    ! [VarCurr] :
      ( v5384(VarCurr)
    <=> ( v5355(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_367,axiom,
    ! [VarCurr] :
      ( v5383(VarCurr)
    <=> ( v5355(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_366,axiom,
    ! [VarCurr] :
      ( v5381(VarCurr)
    <=> ( ( v5329(VarCurr,bitIndex1)
        <=> $false )
        & ( v5329(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_120,axiom,
    ! [VarCurr] :
      ( ~ v5379(VarCurr)
     => ( v5378(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_114,axiom,
    ! [VarCurr] :
      ( v5379(VarCurr)
     => ( v5378(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_365,axiom,
    ! [VarCurr] :
      ( v5380(VarCurr)
    <=> ( v5333(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_364,axiom,
    ! [VarCurr] :
      ( v5379(VarCurr)
    <=> ( v5333(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_363,axiom,
    ! [VarCurr] :
      ( v5377(VarCurr)
    <=> ( ( v5329(VarCurr,bitIndex1)
        <=> $false )
        & ( v5329(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignmentInitValueVector_22,axiom,
    ! [B] :
      ( range_1_0(B)
     => ( v5329(constB0,B)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_23,axiom,
    ! [VarCurr] :
      ( ( ~ v5335(VarCurr)
        & ~ v5341(VarCurr)
        & ~ v5353(VarCurr) )
     => ( v5333(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_50,axiom,
    ! [VarCurr] :
      ( v5353(VarCurr)
     => ( v5333(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_119,axiom,
    ! [VarCurr] :
      ( v5341(VarCurr)
     => ( v5333(VarCurr)
      <=> v5342(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_113,axiom,
    ! [VarCurr] :
      ( v5335(VarCurr)
     => ( v5333(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_362,axiom,
    ! [VarCurr] :
      ( v5353(VarCurr)
    <=> ( ( v3186(VarCurr,bitIndex2)
        <=> $true )
        & ( v3186(VarCurr,bitIndex1)
        <=> $false )
        & ( v3186(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_118,axiom,
    ! [VarCurr] :
      ( ~ v5343(VarCurr)
     => ( v5342(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_112,axiom,
    ! [VarCurr] :
      ( v5343(VarCurr)
     => ( v5342(VarCurr)
      <=> v5344(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_361,axiom,
    ! [VarCurr] :
      ( v5352(VarCurr)
    <=> ( v3182(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_49,axiom,
    ! [VarCurr] :
      ( ( ~ v5345(VarCurr)
        & ~ v5347(VarCurr) )
     => ( v5344(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_117,axiom,
    ! [VarCurr] :
      ( v5347(VarCurr)
     => ( v5344(VarCurr)
      <=> v5349(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_111,axiom,
    ! [VarCurr] :
      ( v5345(VarCurr)
     => ( v5344(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_116,axiom,
    ! [VarCurr] :
      ( ~ v5350(VarCurr)
     => ( v5349(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_110,axiom,
    ! [VarCurr] :
      ( v5350(VarCurr)
     => ( v5349(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_360,axiom,
    ! [VarCurr] :
      ( v5351(VarCurr)
    <=> ( v5280(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_359,axiom,
    ! [VarCurr] :
      ( v5350(VarCurr)
    <=> ( v5280(VarCurr)
      <=> $false ) ) ).

fof(addAssignmentInitValueVector_21,axiom,
    ( v5280(constB0)
  <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_358,axiom,
    ! [VarCurr] :
      ( v5347(VarCurr)
    <=> ( ( v5348(VarCurr,bitIndex1)
        <=> $true )
        & ( v5348(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1460,axiom,
    ! [VarCurr] :
      ( v5348(VarCurr,bitIndex0)
    <=> v4697(VarCurr) ) ).

fof(addAssignment_1459,axiom,
    ! [VarCurr] :
      ( v5348(VarCurr,bitIndex1)
    <=> v4670(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_357,axiom,
    ! [VarCurr] :
      ( v5345(VarCurr)
    <=> ( ( v5346(VarCurr,bitIndex1)
        <=> $false )
        & ( v5346(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1458,axiom,
    ! [VarCurr] :
      ( v5346(VarCurr,bitIndex0)
    <=> v4697(VarCurr) ) ).

fof(addAssignment_1457,axiom,
    ! [VarCurr] :
      ( v5346(VarCurr,bitIndex1)
    <=> v4670(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_356,axiom,
    ! [VarCurr] :
      ( v5343(VarCurr)
    <=> ( v3182(VarCurr)
      <=> $false ) ) ).

fof(addAssignmentInitValueVector_20,axiom,
    ( v3182(constB0)
  <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_355,axiom,
    ! [VarCurr] :
      ( v5341(VarCurr)
    <=> ( ( v3186(VarCurr,bitIndex2)
        <=> $false )
        & ( v3186(VarCurr,bitIndex1)
        <=> $true )
        & ( v3186(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_972,axiom,
    ! [VarCurr] :
      ( v5335(VarCurr)
    <=> ( v5337(VarCurr)
        | v5340(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_354,axiom,
    ! [VarCurr] :
      ( v5340(VarCurr)
    <=> ( ( v3186(VarCurr,bitIndex2)
        <=> $false )
        & ( v3186(VarCurr,bitIndex1)
        <=> $true )
        & ( v3186(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_971,axiom,
    ! [VarCurr] :
      ( v5337(VarCurr)
    <=> ( v5338(VarCurr)
        | v5339(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_353,axiom,
    ! [VarCurr] :
      ( v5339(VarCurr)
    <=> ( ( v3186(VarCurr,bitIndex2)
        <=> $false )
        & ( v3186(VarCurr,bitIndex1)
        <=> $false )
        & ( v3186(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_352,axiom,
    ! [VarCurr] :
      ( v5338(VarCurr)
    <=> ( ( v3186(VarCurr,bitIndex2)
        <=> $false )
        & ( v3186(VarCurr,bitIndex1)
        <=> $false )
        & ( v3186(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignmentInitValueVector_19,axiom,
    ! [B] :
      ( range_2_0(B)
     => ( v3186(constB0,B)
      <=> $false ) ) ).

fof(addAssignment_1456,axiom,
    ! [VarCurr] :
      ( v5296(VarCurr)
    <=> v5298(VarCurr) ) ).

fof(addAssignment_1455,axiom,
    ! [VarCurr] :
      ( v5298(VarCurr)
    <=> v5300(VarCurr) ) ).

fof(addAssignment_1454,axiom,
    ! [VarCurr] :
      ( v5300(VarCurr)
    <=> v5302(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_90,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5305(VarNext)
       => ( v5302(VarNext)
        <=> v5302(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_101,axiom,
    ! [VarNext] :
      ( v5305(VarNext)
     => ( v5302(VarNext)
      <=> v5313(VarNext) ) ) ).

fof(addAssignment_1453,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5313(VarNext)
      <=> v5311(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_138,axiom,
    ! [VarCurr] :
      ( ~ v5250(VarCurr)
     => ( v5311(VarCurr)
      <=> v5314(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_140,axiom,
    ! [VarCurr] :
      ( v5250(VarCurr)
     => ( v5311(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_137,axiom,
    ! [VarCurr] :
      ( ~ v5315(VarCurr)
     => ( v5314(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_139,axiom,
    ! [VarCurr] :
      ( v5315(VarCurr)
     => ( v5314(VarCurr)
      <=> v5143(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_351,axiom,
    ! [VarCurr] :
      ( v5315(VarCurr)
    <=> ( ( v4954(VarCurr,bitIndex2)
        <=> $false )
        & ( v4954(VarCurr,bitIndex1)
        <=> $true )
        & ( v4954(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_970,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5305(VarNext)
      <=> v5306(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_969,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5306(VarNext)
      <=> ( v5308(VarNext)
          & v4988(VarNext) ) ) ) ).

fof(writeUnaryOperator_398,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5308(VarNext)
      <=> v4995(VarNext) ) ) ).

fof(addAssignment_1452,axiom,
    ! [VarCurr] :
      ( v5294(VarCurr)
    <=> v4942(VarCurr) ) ).

fof(addAssignment_1451,axiom,
    ! [VarCurr] :
      ( v5292(VarCurr)
    <=> v4937(VarCurr) ) ).

fof(addAssignment_1450,axiom,
    ! [VarCurr] :
      ( v4944(VarCurr)
    <=> v4946(VarCurr) ) ).

fof(addAssignment_1449,axiom,
    ! [VarCurr] :
      ( v4946(VarCurr)
    <=> v4948(VarCurr) ) ).

fof(addAssignment_1448,axiom,
    ! [VarCurr] :
      ( v4948(VarCurr)
    <=> v4950(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_89,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5255(VarNext)
       => ( v4950(VarNext)
        <=> v4950(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_100,axiom,
    ! [VarNext] :
      ( v5255(VarNext)
     => ( v4950(VarNext)
      <=> v5263(VarNext) ) ) ).

fof(addAssignment_1447,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5263(VarNext)
      <=> v5261(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_136,axiom,
    ! [VarCurr] :
      ( ~ v5250(VarCurr)
     => ( v5261(VarCurr)
      <=> v5264(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_138,axiom,
    ! [VarCurr] :
      ( v5250(VarCurr)
     => ( v5261(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_135,axiom,
    ! [VarCurr] :
      ( ~ v5265(VarCurr)
     => ( v5264(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_137,axiom,
    ! [VarCurr] :
      ( v5265(VarCurr)
     => ( v5264(VarCurr)
      <=> v5141(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_968,axiom,
    ! [VarCurr] :
      ( v5265(VarCurr)
    <=> ( v5266(VarCurr)
        & v5016(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_350,axiom,
    ! [VarCurr] :
      ( v5266(VarCurr)
    <=> ( ( v4954(VarCurr,bitIndex2)
        <=> $false )
        & ( v4954(VarCurr,bitIndex1)
        <=> $true )
        & ( v4954(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_967,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5255(VarNext)
      <=> v5256(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_966,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5256(VarNext)
      <=> ( v5258(VarNext)
          & v4988(VarNext) ) ) ) ).

fof(writeUnaryOperator_397,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5258(VarNext)
      <=> v4995(VarNext) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_88,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5241(VarNext)
       => ( v5141(VarNext)
        <=> v5141(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_99,axiom,
    ! [VarNext] :
      ( v5241(VarNext)
     => ( v5141(VarNext)
      <=> v5249(VarNext) ) ) ).

fof(addAssignment_1446,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5249(VarNext)
      <=> v5247(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_134,axiom,
    ! [VarCurr] :
      ( ~ v5250(VarCurr)
     => ( v5247(VarCurr)
      <=> v5143(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_136,axiom,
    ! [VarCurr] :
      ( v5250(VarCurr)
     => ( v5247(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_349,axiom,
    ! [VarCurr] :
      ( v5250(VarCurr)
    <=> ( v4952(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_965,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5241(VarNext)
      <=> v5242(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_964,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5242(VarNext)
      <=> ( v5243(VarNext)
          & v4988(VarNext) ) ) ) ).

fof(writeUnaryOperator_396,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5243(VarNext)
      <=> v4995(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_22,axiom,
    ! [VarCurr] :
      ( ( ~ v4968(VarCurr)
        & ~ v4985(VarCurr)
        & ~ v4986(VarCurr) )
     => ( v5143(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_48,axiom,
    ! [VarCurr] :
      ( v4986(VarCurr)
     => ( v5143(VarCurr)
      <=> v5211(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_115,axiom,
    ! [VarCurr] :
      ( v4985(VarCurr)
     => ( v5143(VarCurr)
      <=> v5197(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_109,axiom,
    ! [VarCurr] :
      ( v4968(VarCurr)
     => ( v5143(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_114,axiom,
    ! [VarCurr] :
      ( ~ v5212(VarCurr)
     => ( v5211(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_108,axiom,
    ! [VarCurr] :
      ( v5212(VarCurr)
     => ( v5211(VarCurr)
      <=> v5213(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_348,axiom,
    ! [VarCurr] :
      ( v5238(VarCurr)
    <=> ( v5145(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_21,axiom,
    ! [VarCurr] :
      ( ( ~ v5214(VarCurr)
        & ~ v5216(VarCurr)
        & ~ v5227(VarCurr) )
     => ( v5213(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_47,axiom,
    ! [VarCurr] :
      ( v5227(VarCurr)
     => ( v5213(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_113,axiom,
    ! [VarCurr] :
      ( v5216(VarCurr)
     => ( v5213(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_107,axiom,
    ! [VarCurr] :
      ( v5214(VarCurr)
     => ( v5213(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_963,axiom,
    ! [VarCurr] :
      ( v5227(VarCurr)
    <=> ( v5228(VarCurr)
        | v5236(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_347,axiom,
    ! [VarCurr] :
      ( v5236(VarCurr)
    <=> ( ( v5237(VarCurr,bitIndex3)
        <=> $false )
        & ( v5237(VarCurr,bitIndex2)
        <=> $true )
        & ( v5237(VarCurr,bitIndex1)
        <=> $false )
        & ( v5237(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1445,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v5237(VarCurr,B)
      <=> v4954(VarCurr,B) ) ) ).

fof(addAssignment_1444,axiom,
    ! [VarCurr] :
      ( v5237(VarCurr,bitIndex3)
    <=> v5163(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_962,axiom,
    ! [VarCurr] :
      ( v5228(VarCurr)
    <=> ( v5229(VarCurr)
        | v5234(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_346,axiom,
    ! [VarCurr] :
      ( v5234(VarCurr)
    <=> ( ( v5235(VarCurr,bitIndex3)
        <=> $false )
        & ( v5235(VarCurr,bitIndex2)
        <=> $true )
        & ( v5235(VarCurr,bitIndex1)
        <=> $true )
        & ( v5235(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1443,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v5235(VarCurr,B)
      <=> v4954(VarCurr,B) ) ) ).

fof(addAssignment_1442,axiom,
    ! [VarCurr] :
      ( v5235(VarCurr,bitIndex3)
    <=> v5163(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_961,axiom,
    ! [VarCurr] :
      ( v5229(VarCurr)
    <=> ( v5230(VarCurr)
        | v5232(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_345,axiom,
    ! [VarCurr] :
      ( v5232(VarCurr)
    <=> ( ( v5233(VarCurr,bitIndex3)
        <=> $false )
        & ( v5233(VarCurr,bitIndex2)
        <=> $true )
        & ( v5233(VarCurr,bitIndex1)
        <=> $false )
        & ( v5233(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1441,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v5233(VarCurr,B)
      <=> v4954(VarCurr,B) ) ) ).

fof(addAssignment_1440,axiom,
    ! [VarCurr] :
      ( v5233(VarCurr,bitIndex3)
    <=> v5163(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_344,axiom,
    ! [VarCurr] :
      ( v5230(VarCurr)
    <=> ( ( v5231(VarCurr,bitIndex3)
        <=> $false )
        & ( v5231(VarCurr,bitIndex2)
        <=> $false )
        & ( v5231(VarCurr,bitIndex1)
        <=> $false )
        & ( v5231(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1439,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v5231(VarCurr,B)
      <=> v4954(VarCurr,B) ) ) ).

fof(addAssignment_1438,axiom,
    ! [VarCurr] :
      ( v5231(VarCurr,bitIndex3)
    <=> v5163(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_960,axiom,
    ! [VarCurr] :
      ( v5216(VarCurr)
    <=> ( v5217(VarCurr)
        | v5225(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_343,axiom,
    ! [VarCurr] :
      ( v5225(VarCurr)
    <=> ( ( v5226(VarCurr,bitIndex3)
        <=> $true )
        & ( v5226(VarCurr,bitIndex2)
        <=> $true )
        & ( v5226(VarCurr,bitIndex1)
        <=> $false )
        & ( v5226(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1437,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v5226(VarCurr,B)
      <=> v4954(VarCurr,B) ) ) ).

fof(addAssignment_1436,axiom,
    ! [VarCurr] :
      ( v5226(VarCurr,bitIndex3)
    <=> v5163(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_959,axiom,
    ! [VarCurr] :
      ( v5217(VarCurr)
    <=> ( v5218(VarCurr)
        | v5223(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_342,axiom,
    ! [VarCurr] :
      ( v5223(VarCurr)
    <=> ( ( v5224(VarCurr,bitIndex3)
        <=> $true )
        & ( v5224(VarCurr,bitIndex2)
        <=> $true )
        & ( v5224(VarCurr,bitIndex1)
        <=> $true )
        & ( v5224(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1435,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v5224(VarCurr,B)
      <=> v4954(VarCurr,B) ) ) ).

fof(addAssignment_1434,axiom,
    ! [VarCurr] :
      ( v5224(VarCurr,bitIndex3)
    <=> v5163(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_958,axiom,
    ! [VarCurr] :
      ( v5218(VarCurr)
    <=> ( v5219(VarCurr)
        | v5221(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_341,axiom,
    ! [VarCurr] :
      ( v5221(VarCurr)
    <=> ( ( v5222(VarCurr,bitIndex3)
        <=> $true )
        & ( v5222(VarCurr,bitIndex2)
        <=> $true )
        & ( v5222(VarCurr,bitIndex1)
        <=> $false )
        & ( v5222(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1433,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v5222(VarCurr,B)
      <=> v4954(VarCurr,B) ) ) ).

fof(addAssignment_1432,axiom,
    ! [VarCurr] :
      ( v5222(VarCurr,bitIndex3)
    <=> v5163(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_340,axiom,
    ! [VarCurr] :
      ( v5219(VarCurr)
    <=> ( ( v5220(VarCurr,bitIndex3)
        <=> $true )
        & ( v5220(VarCurr,bitIndex2)
        <=> $false )
        & ( v5220(VarCurr,bitIndex1)
        <=> $true )
        & ( v5220(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1431,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v5220(VarCurr,B)
      <=> v4954(VarCurr,B) ) ) ).

fof(addAssignment_1430,axiom,
    ! [VarCurr] :
      ( v5220(VarCurr,bitIndex3)
    <=> v5163(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_339,axiom,
    ! [VarCurr] :
      ( v5214(VarCurr)
    <=> ( ( v5215(VarCurr,bitIndex3)
        <=> $true )
        & ( v5215(VarCurr,bitIndex2)
        <=> $false )
        & ( v5215(VarCurr,bitIndex1)
        <=> $false )
        & ( v5215(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1429,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v5215(VarCurr,B)
      <=> v4954(VarCurr,B) ) ) ).

fof(addAssignment_1428,axiom,
    ! [VarCurr] :
      ( v5215(VarCurr,bitIndex3)
    <=> v5163(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_338,axiom,
    ! [VarCurr] :
      ( v5212(VarCurr)
    <=> ( v5145(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_112,axiom,
    ! [VarCurr] :
      ( ~ v5198(VarCurr)
     => ( v5197(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_106,axiom,
    ! [VarCurr] :
      ( v5198(VarCurr)
     => ( v5197(VarCurr)
      <=> v5199(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_337,axiom,
    ! [VarCurr] :
      ( v5210(VarCurr)
    <=> ( v5145(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_20,axiom,
    ! [VarCurr] :
      ( ( ~ v5200(VarCurr)
        & ~ v5202(VarCurr)
        & ~ v5204(VarCurr) )
     => ( v5199(VarCurr)
      <=> v5208(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_46,axiom,
    ! [VarCurr] :
      ( v5204(VarCurr)
     => ( v5199(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_111,axiom,
    ! [VarCurr] :
      ( v5202(VarCurr)
     => ( v5199(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_105,axiom,
    ! [VarCurr] :
      ( v5200(VarCurr)
     => ( v5199(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_133,axiom,
    ! [VarCurr] :
      ( ~ v5209(VarCurr)
     => ( v5208(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_135,axiom,
    ! [VarCurr] :
      ( v5209(VarCurr)
     => ( v5208(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_336,axiom,
    ! [VarCurr] :
      ( v5209(VarCurr)
    <=> ( ( v5195(VarCurr,bitIndex5)
        <=> $false )
        & ( v5195(VarCurr,bitIndex4)
        <=> $false )
        & ( v5195(VarCurr,bitIndex3)
        <=> $false )
        & ( v5195(VarCurr,bitIndex2)
        <=> $false )
        & ( v5195(VarCurr,bitIndex1)
        <=> $false )
        & ( v5195(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_397,axiom,
    ~ b000001(bitIndex5) ).

fof(bitBlastConstant_396,axiom,
    ~ b000001(bitIndex4) ).

fof(bitBlastConstant_395,axiom,
    ~ b000001(bitIndex3) ).

fof(bitBlastConstant_394,axiom,
    ~ b000001(bitIndex2) ).

fof(bitBlastConstant_393,axiom,
    ~ b000001(bitIndex1) ).

fof(bitBlastConstant_392,axiom,
    b000001(bitIndex0) ).

fof(addBitVectorEqualityBitBlasted_335,axiom,
    ! [VarCurr] :
      ( v5206(VarCurr)
    <=> ( ( v5207(VarCurr,bitIndex1)
        <=> $true )
        & ( v5207(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1427,axiom,
    ! [VarCurr] :
      ( v5207(VarCurr,bitIndex0)
    <=> v5165(VarCurr) ) ).

fof(addAssignment_1426,axiom,
    ! [VarCurr] :
      ( v5207(VarCurr,bitIndex1)
    <=> v5163(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_334,axiom,
    ! [VarCurr] :
      ( v5204(VarCurr)
    <=> ( ( v5205(VarCurr,bitIndex1)
        <=> $true )
        & ( v5205(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1425,axiom,
    ! [VarCurr] :
      ( v5205(VarCurr,bitIndex0)
    <=> v5165(VarCurr) ) ).

fof(addAssignment_1424,axiom,
    ! [VarCurr] :
      ( v5205(VarCurr,bitIndex1)
    <=> v5163(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_333,axiom,
    ! [VarCurr] :
      ( v5202(VarCurr)
    <=> ( ( v5203(VarCurr,bitIndex1)
        <=> $false )
        & ( v5203(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1423,axiom,
    ! [VarCurr] :
      ( v5203(VarCurr,bitIndex0)
    <=> v5165(VarCurr) ) ).

fof(addAssignment_1422,axiom,
    ! [VarCurr] :
      ( v5203(VarCurr,bitIndex1)
    <=> v5163(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_332,axiom,
    ! [VarCurr] :
      ( v5200(VarCurr)
    <=> ( ( v5201(VarCurr,bitIndex1)
        <=> $false )
        & ( v5201(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1421,axiom,
    ! [VarCurr] :
      ( v5201(VarCurr,bitIndex0)
    <=> v5165(VarCurr) ) ).

fof(addAssignment_1420,axiom,
    ! [VarCurr] :
      ( v5201(VarCurr,bitIndex1)
    <=> v5163(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_331,axiom,
    ! [VarCurr] :
      ( v5198(VarCurr)
    <=> ( v5145(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_19,axiom,
    ! [VarCurr] :
      ( ( ~ v5177(VarCurr)
        & ~ v5178(VarCurr)
        & ~ v5190(VarCurr) )
     => ( v5165(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_45,axiom,
    ! [VarCurr] :
      ( v5190(VarCurr)
     => ( v5165(VarCurr)
      <=> v5191(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_110,axiom,
    ! [VarCurr] :
      ( v5178(VarCurr)
     => ( v5165(VarCurr)
      <=> v5179(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_104,axiom,
    ! [VarCurr] :
      ( v5177(VarCurr)
     => ( v5165(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_109,axiom,
    ! [VarCurr] :
      ( ~ v5192(VarCurr)
     => ( v5191(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_103,axiom,
    ! [VarCurr] :
      ( v5192(VarCurr)
     => ( v5191(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_330,axiom,
    ! [VarCurr] :
      ( v5193(VarCurr)
    <=> ( v5145(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_329,axiom,
    ! [VarCurr] :
      ( v5192(VarCurr)
    <=> ( v5145(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_328,axiom,
    ! [VarCurr] :
      ( v5190(VarCurr)
    <=> ( ( v5167(VarCurr,bitIndex1)
        <=> $true )
        & ( v5167(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_108,axiom,
    ! [VarCurr] :
      ( ~ v5180(VarCurr)
     => ( v5179(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_102,axiom,
    ! [VarCurr] :
      ( v5180(VarCurr)
     => ( v5179(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_327,axiom,
    ! [VarCurr] :
      ( v5188(VarCurr)
    <=> ( ( v5189(VarCurr,bitIndex1)
        <=> $true )
        & ( v5189(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1419,axiom,
    ! [VarCurr] :
      ( v5189(VarCurr,bitIndex0)
    <=> v5145(VarCurr) ) ).

fof(addAssignment_1418,axiom,
    ! [VarCurr] :
      ( v5189(VarCurr,bitIndex1)
    <=> v5169(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_957,axiom,
    ! [VarCurr] :
      ( v5180(VarCurr)
    <=> ( v5181(VarCurr)
        | v5186(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_326,axiom,
    ! [VarCurr] :
      ( v5186(VarCurr)
    <=> ( ( v5187(VarCurr,bitIndex1)
        <=> $true )
        & ( v5187(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1417,axiom,
    ! [VarCurr] :
      ( v5187(VarCurr,bitIndex0)
    <=> v5145(VarCurr) ) ).

fof(addAssignment_1416,axiom,
    ! [VarCurr] :
      ( v5187(VarCurr,bitIndex1)
    <=> v5169(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_956,axiom,
    ! [VarCurr] :
      ( v5181(VarCurr)
    <=> ( v5182(VarCurr)
        | v5184(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_325,axiom,
    ! [VarCurr] :
      ( v5184(VarCurr)
    <=> ( ( v5185(VarCurr,bitIndex1)
        <=> $false )
        & ( v5185(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1415,axiom,
    ! [VarCurr] :
      ( v5185(VarCurr,bitIndex0)
    <=> v5145(VarCurr) ) ).

fof(addAssignment_1414,axiom,
    ! [VarCurr] :
      ( v5185(VarCurr,bitIndex1)
    <=> v5169(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_324,axiom,
    ! [VarCurr] :
      ( v5182(VarCurr)
    <=> ( ( v5183(VarCurr,bitIndex1)
        <=> $false )
        & ( v5183(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1413,axiom,
    ! [VarCurr] :
      ( v5183(VarCurr,bitIndex0)
    <=> v5145(VarCurr) ) ).

fof(addAssignment_1412,axiom,
    ! [VarCurr] :
      ( v5183(VarCurr,bitIndex1)
    <=> v5169(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_323,axiom,
    ! [VarCurr] :
      ( v5178(VarCurr)
    <=> ( ( v5167(VarCurr,bitIndex1)
        <=> $false )
        & ( v5167(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_322,axiom,
    ! [VarCurr] :
      ( v5177(VarCurr)
    <=> ( ( v5167(VarCurr,bitIndex1)
        <=> $false )
        & ( v5167(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1411,axiom,
    ! [VarCurr] :
      ( v5169(VarCurr)
    <=> v5171(VarCurr) ) ).

fof(addAssignment_1410,axiom,
    ! [VarCurr] :
      ( v5171(VarCurr)
    <=> v5173(VarCurr) ) ).

fof(addAssignment_1409,axiom,
    ! [VarCurr] :
      ( v5173(VarCurr)
    <=> v5175(VarCurr) ) ).

fof(addAssignment_1408,axiom,
    ! [VarCurr] :
      ( v5145(VarCurr)
    <=> v5147(VarCurr) ) ).

fof(addAssignment_1407,axiom,
    ! [VarCurr] :
      ( v5147(VarCurr)
    <=> v5149(VarCurr) ) ).

fof(addAssignment_1406,axiom,
    ! [VarCurr] :
      ( v5149(VarCurr)
    <=> v5151(VarCurr) ) ).

fof(addAssignment_1405,axiom,
    ! [VarCurr] :
      ( v5151(VarCurr)
    <=> v5153(VarCurr) ) ).

fof(addAssignment_1404,axiom,
    ! [VarCurr] :
      ( v5153(VarCurr)
    <=> v5155(VarCurr) ) ).

fof(addAssignment_1403,axiom,
    ! [VarCurr] :
      ( v5155(VarCurr)
    <=> v5157(VarCurr) ) ).

fof(addAssignment_1402,axiom,
    ! [VarCurr] :
      ( v5157(VarCurr)
    <=> v5159(VarCurr) ) ).

fof(addAssignment_1401,axiom,
    ! [VarCurr] :
      ( v5159(VarCurr)
    <=> v5161(VarCurr,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_87,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5125(VarNext)
       => ( v5016(VarNext)
        <=> v5016(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_98,axiom,
    ! [VarNext] :
      ( v5125(VarNext)
     => ( v5016(VarNext)
      <=> v5133(VarNext) ) ) ).

fof(addAssignment_1400,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5133(VarNext)
      <=> v5131(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_132,axiom,
    ! [VarCurr] :
      ( ~ v5134(VarCurr)
     => ( v5131(VarCurr)
      <=> v5135(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_134,axiom,
    ! [VarCurr] :
      ( v5134(VarCurr)
     => ( v5131(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_131,axiom,
    ! [VarCurr] :
      ( ~ v5018(VarCurr)
     => ( v5135(VarCurr)
      <=> v5136(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_133,axiom,
    ! [VarCurr] :
      ( v5018(VarCurr)
     => ( v5135(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_955,axiom,
    ! [VarCurr] :
      ( v5136(VarCurr)
    <=> ( v5137(VarCurr)
        & v5016(VarCurr) ) ) ).

fof(writeUnaryOperator_395,axiom,
    ! [VarCurr] :
      ( ~ v5137(VarCurr)
    <=> v4950(VarCurr) ) ).

fof(addAssignmentInitValueVector_18,axiom,
    ( v4950(constB0)
  <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_321,axiom,
    ! [VarCurr] :
      ( v5134(VarCurr)
    <=> ( v4952(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_954,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5125(VarNext)
      <=> v5126(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_953,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5126(VarNext)
      <=> ( v5127(VarNext)
          & v4988(VarNext) ) ) ) ).

fof(writeUnaryOperator_394,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5127(VarNext)
      <=> v4995(VarNext) ) ) ).

fof(addAssignment_1399,axiom,
    ! [VarCurr] :
      ( v5018(VarCurr)
    <=> v5020(VarCurr) ) ).

fof(addAssignment_1398,axiom,
    ! [VarCurr] :
      ( v5020(VarCurr)
    <=> v5022(VarCurr) ) ).

fof(addAssignment_1397,axiom,
    ! [VarCurr] :
      ( v5022(VarCurr)
    <=> v5024(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_86,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5109(VarNext)
       => ( v5024(VarNext)
        <=> v5024(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_97,axiom,
    ! [VarNext] :
      ( v5109(VarNext)
     => ( v5024(VarNext)
      <=> v5119(VarNext) ) ) ).

fof(addAssignment_1396,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5119(VarNext)
      <=> v5117(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_130,axiom,
    ! [VarCurr] :
      ( ~ v5120(VarCurr)
     => ( v5117(VarCurr)
      <=> v5026(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_132,axiom,
    ! [VarCurr] :
      ( v5120(VarCurr)
     => ( v5117(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_320,axiom,
    ! [VarCurr] :
      ( v5120(VarCurr)
    <=> ( v4942(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_952,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5109(VarNext)
      <=> v5110(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_951,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5110(VarNext)
      <=> ( v5111(VarNext)
          & v4937(VarNext) ) ) ) ).

fof(writeUnaryOperator_393,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5111(VarNext)
      <=> v5113(VarNext) ) ) ).

fof(addAssignment_1395,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5113(VarNext)
      <=> v4937(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_44,axiom,
    ! [VarCurr] :
      ( ( ~ v5102(VarCurr)
        & ~ v5106(VarCurr) )
     => ( v5026(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_107,axiom,
    ! [VarCurr] :
      ( v5106(VarCurr)
     => ( v5026(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_101,axiom,
    ! [VarCurr] :
      ( v5102(VarCurr)
     => ( v5026(VarCurr)
      <=> v5103(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_319,axiom,
    ! [VarCurr] :
      ( v5106(VarCurr)
    <=> ( ( v5028(VarCurr,bitIndex1)
        <=> $false )
        & ( v5028(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_129,axiom,
    ! [VarCurr] :
      ( ~ v5030(VarCurr)
     => ( v5103(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_131,axiom,
    ! [VarCurr] :
      ( v5030(VarCurr)
     => ( v5103(VarCurr)
      <=> v5104(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_128,axiom,
    ! [VarCurr] :
      ( ~ v5105(VarCurr)
     => ( v5104(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_130,axiom,
    ! [VarCurr] :
      ( v5105(VarCurr)
     => ( v5104(VarCurr)
      <=> $false ) ) ).

fof(writeUnaryOperator_392,axiom,
    ! [VarCurr] :
      ( ~ v5105(VarCurr)
    <=> v5036(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_318,axiom,
    ! [VarCurr] :
      ( v5102(VarCurr)
    <=> ( ( v5028(VarCurr,bitIndex1)
        <=> $false )
        & ( v5028(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1394,axiom,
    ! [VarCurr] :
      ( v5036(VarCurr)
    <=> v5038(VarCurr) ) ).

fof(addAssignment_1393,axiom,
    ! [VarCurr] :
      ( v5038(VarCurr)
    <=> v5100(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_85,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5051(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v5042(VarNext,B)
            <=> v5042(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_96,axiom,
    ! [VarNext] :
      ( v5051(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v5042(VarNext,B)
          <=> v5072(VarNext,B) ) ) ) ).

fof(addAssignment_1392,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v5072(VarNext,B)
          <=> v5070(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_106,axiom,
    ! [VarCurr] :
      ( ~ v5063(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v5070(VarCurr,B)
          <=> v5073(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_100,axiom,
    ! [VarCurr] :
      ( v5063(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v5070(VarCurr,B)
          <=> $false ) ) ) ).

fof(addAssignment_1391,axiom,
    ! [VarCurr] :
      ( v5073(VarCurr,bitIndex0)
    <=> v5095(VarCurr) ) ).

fof(addAssignment_1390,axiom,
    ! [VarCurr] :
      ( v5073(VarCurr,bitIndex1)
    <=> v5093(VarCurr) ) ).

fof(addAssignment_1389,axiom,
    ! [VarCurr] :
      ( v5073(VarCurr,bitIndex2)
    <=> v5088(VarCurr) ) ).

fof(addAssignment_1388,axiom,
    ! [VarCurr] :
      ( v5073(VarCurr,bitIndex3)
    <=> v5083(VarCurr) ) ).

fof(addAssignment_1387,axiom,
    ! [VarCurr] :
      ( v5073(VarCurr,bitIndex4)
    <=> v5075(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_950,axiom,
    ! [VarCurr] :
      ( v5093(VarCurr)
    <=> ( v5094(VarCurr)
        & v5097(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_138,axiom,
    ! [VarCurr] :
      ( v5097(VarCurr)
    <=> ( v5042(VarCurr,bitIndex0)
        | v5042(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_949,axiom,
    ! [VarCurr] :
      ( v5094(VarCurr)
    <=> ( v5095(VarCurr)
        | v5096(VarCurr) ) ) ).

fof(writeUnaryOperator_391,axiom,
    ! [VarCurr] :
      ( ~ v5096(VarCurr)
    <=> v5042(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_390,axiom,
    ! [VarCurr] :
      ( ~ v5095(VarCurr)
    <=> v5042(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_948,axiom,
    ! [VarCurr] :
      ( v5088(VarCurr)
    <=> ( v5089(VarCurr)
        & v5092(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_137,axiom,
    ! [VarCurr] :
      ( v5092(VarCurr)
    <=> ( v5080(VarCurr)
        | v5042(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_947,axiom,
    ! [VarCurr] :
      ( v5089(VarCurr)
    <=> ( v5090(VarCurr)
        | v5091(VarCurr) ) ) ).

fof(writeUnaryOperator_389,axiom,
    ! [VarCurr] :
      ( ~ v5091(VarCurr)
    <=> v5042(VarCurr,bitIndex2) ) ).

fof(writeUnaryOperator_388,axiom,
    ! [VarCurr] :
      ( ~ v5090(VarCurr)
    <=> v5080(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_946,axiom,
    ! [VarCurr] :
      ( v5083(VarCurr)
    <=> ( v5084(VarCurr)
        & v5087(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_136,axiom,
    ! [VarCurr] :
      ( v5087(VarCurr)
    <=> ( v5079(VarCurr)
        | v5042(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_945,axiom,
    ! [VarCurr] :
      ( v5084(VarCurr)
    <=> ( v5085(VarCurr)
        | v5086(VarCurr) ) ) ).

fof(writeUnaryOperator_387,axiom,
    ! [VarCurr] :
      ( ~ v5086(VarCurr)
    <=> v5042(VarCurr,bitIndex3) ) ).

fof(writeUnaryOperator_386,axiom,
    ! [VarCurr] :
      ( ~ v5085(VarCurr)
    <=> v5079(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_944,axiom,
    ! [VarCurr] :
      ( v5075(VarCurr)
    <=> ( v5076(VarCurr)
        & v5082(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_135,axiom,
    ! [VarCurr] :
      ( v5082(VarCurr)
    <=> ( v5078(VarCurr)
        | v5042(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_943,axiom,
    ! [VarCurr] :
      ( v5076(VarCurr)
    <=> ( v5077(VarCurr)
        | v5081(VarCurr) ) ) ).

fof(writeUnaryOperator_385,axiom,
    ! [VarCurr] :
      ( ~ v5081(VarCurr)
    <=> v5042(VarCurr,bitIndex4) ) ).

fof(writeUnaryOperator_384,axiom,
    ! [VarCurr] :
      ( ~ v5077(VarCurr)
    <=> v5078(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_134,axiom,
    ! [VarCurr] :
      ( v5078(VarCurr)
    <=> ( v5079(VarCurr)
        & v5042(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_133,axiom,
    ! [VarCurr] :
      ( v5079(VarCurr)
    <=> ( v5080(VarCurr)
        & v5042(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_132,axiom,
    ! [VarCurr] :
      ( v5080(VarCurr)
    <=> ( v5042(VarCurr,bitIndex0)
        & v5042(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_942,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5051(VarNext)
      <=> ( v5052(VarNext)
          & v5061(VarNext) ) ) ) ).

fof(addAssignment_1386,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5061(VarNext)
      <=> v5059(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_941,axiom,
    ! [VarCurr] :
      ( v5059(VarCurr)
    <=> ( v5062(VarCurr)
        & v5067(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_940,axiom,
    ! [VarCurr] :
      ( v5067(VarCurr)
    <=> ( v5068(VarCurr)
        | v5063(VarCurr) ) ) ).

fof(writeUnaryOperator_383,axiom,
    ! [VarCurr] :
      ( ~ v5068(VarCurr)
    <=> v5069(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_317,axiom,
    ! [VarCurr] :
      ( v5069(VarCurr)
    <=> ( v5046(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_939,axiom,
    ! [VarCurr] :
      ( v5062(VarCurr)
    <=> ( v5063(VarCurr)
        | v5064(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_938,axiom,
    ! [VarCurr] :
      ( v5064(VarCurr)
    <=> ( v5065(VarCurr)
        & v5066(VarCurr) ) ) ).

fof(writeUnaryOperator_382,axiom,
    ! [VarCurr] :
      ( ~ v5066(VarCurr)
    <=> v5063(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_316,axiom,
    ! [VarCurr] :
      ( v5065(VarCurr)
    <=> ( v5046(VarCurr)
      <=> $true ) ) ).

fof(writeUnaryOperator_381,axiom,
    ! [VarCurr] :
      ( ~ v5063(VarCurr)
    <=> v5044(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_937,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5052(VarNext)
      <=> ( v5053(VarNext)
          & v5048(VarNext) ) ) ) ).

fof(writeUnaryOperator_380,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v5053(VarNext)
      <=> v5055(VarNext) ) ) ).

fof(addAssignment_1385,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5055(VarNext)
      <=> v5048(VarCurr) ) ) ).

fof(addAssignment_1384,axiom,
    ! [VarCurr] :
      ( v5048(VarCurr)
    <=> v4937(VarCurr) ) ).

fof(addAssignment_1383,axiom,
    ! [VarCurr] :
      ( v5046(VarCurr)
    <=> v5024(VarCurr) ) ).

fof(addAssignment_1382,axiom,
    ! [VarCurr] :
      ( v5044(VarCurr)
    <=> v4942(VarCurr) ) ).

fof(addAssignment_1381,axiom,
    ! [VarCurr] :
      ( v5030(VarCurr)
    <=> v5032(VarCurr) ) ).

fof(addAssignment_1380,axiom,
    ! [VarCurr] :
      ( v5032(VarCurr)
    <=> v5034(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_84,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4991(VarNext)
       => ! [B] :
            ( range_2_0(B)
           => ( v4954(VarNext,B)
            <=> v4954(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_95,axiom,
    ! [VarNext] :
      ( v4991(VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v4954(VarNext,B)
          <=> v5012(VarNext,B) ) ) ) ).

fof(addAssignment_1379,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v5012(VarNext,B)
          <=> v5010(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_105,axiom,
    ! [VarCurr] :
      ( ~ v5003(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v5010(VarCurr,B)
          <=> v4965(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_99,axiom,
    ! [VarCurr] :
      ( v5003(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v5010(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_936,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4991(VarNext)
      <=> ( v4992(VarNext)
          & v5001(VarNext) ) ) ) ).

fof(addAssignment_1378,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v5001(VarNext)
      <=> v4999(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_935,axiom,
    ! [VarCurr] :
      ( v4999(VarCurr)
    <=> ( v5002(VarCurr)
        & v5007(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_934,axiom,
    ! [VarCurr] :
      ( v5007(VarCurr)
    <=> ( v5008(VarCurr)
        | v5003(VarCurr) ) ) ).

fof(writeUnaryOperator_379,axiom,
    ! [VarCurr] :
      ( ~ v5008(VarCurr)
    <=> v5009(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_315,axiom,
    ! [VarCurr] :
      ( v5009(VarCurr)
    <=> ( v4956(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_933,axiom,
    ! [VarCurr] :
      ( v5002(VarCurr)
    <=> ( v5003(VarCurr)
        | v5004(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_932,axiom,
    ! [VarCurr] :
      ( v5004(VarCurr)
    <=> ( v5005(VarCurr)
        & v5006(VarCurr) ) ) ).

fof(writeUnaryOperator_378,axiom,
    ! [VarCurr] :
      ( ~ v5006(VarCurr)
    <=> v5003(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_314,axiom,
    ! [VarCurr] :
      ( v5005(VarCurr)
    <=> ( v4956(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_313,axiom,
    ! [VarCurr] :
      ( v5003(VarCurr)
    <=> ( v4952(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_931,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4992(VarNext)
      <=> ( v4993(VarNext)
          & v4988(VarNext) ) ) ) ).

fof(writeUnaryOperator_377,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4993(VarNext)
      <=> v4995(VarNext) ) ) ).

fof(addAssignment_1377,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4995(VarNext)
      <=> v4988(VarCurr) ) ) ).

fof(addAssignment_1376,axiom,
    ! [VarCurr] :
      ( v4988(VarCurr)
    <=> v172(VarCurr) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_43,axiom,
    ! [VarCurr] :
      ( ( ~ v4968(VarCurr)
        & ~ v4984(VarCurr) )
     => ( v4956(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_104,axiom,
    ! [VarCurr] :
      ( v4984(VarCurr)
     => ( v4956(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_98,axiom,
    ! [VarCurr] :
      ( v4968(VarCurr)
     => ( v4956(VarCurr)
      <=> v4969(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_930,axiom,
    ! [VarCurr] :
      ( v4984(VarCurr)
    <=> ( v4985(VarCurr)
        | v4986(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_312,axiom,
    ! [VarCurr] :
      ( v4986(VarCurr)
    <=> ( ( v4958(VarCurr,bitIndex2)
        <=> $false )
        & ( v4958(VarCurr,bitIndex1)
        <=> $true )
        & ( v4958(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_311,axiom,
    ! [VarCurr] :
      ( v4985(VarCurr)
    <=> ( ( v4958(VarCurr,bitIndex2)
        <=> $false )
        & ( v4958(VarCurr,bitIndex1)
        <=> $true )
        & ( v4958(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_103,axiom,
    ! [VarCurr] :
      ( ~ v4970(VarCurr)
     => ( v4969(VarCurr)
      <=> v4972(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_97,axiom,
    ! [VarCurr] :
      ( v4970(VarCurr)
     => ( v4969(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_102,axiom,
    ! [VarCurr] :
      ( ~ v4973(VarCurr)
     => ( v4972(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_96,axiom,
    ! [VarCurr] :
      ( v4973(VarCurr)
     => ( v4972(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_929,axiom,
    ! [VarCurr] :
      ( v4973(VarCurr)
    <=> ( v4974(VarCurr)
        | v4975(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_928,axiom,
    ! [VarCurr] :
      ( v4975(VarCurr)
    <=> ( v4976(VarCurr)
        | v4983(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_310,axiom,
    ! [VarCurr] :
      ( v4983(VarCurr)
    <=> ( ( v4965(VarCurr,bitIndex2)
        <=> $true )
        & ( v4965(VarCurr,bitIndex1)
        <=> $true )
        & ( v4965(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_391,axiom,
    b110(bitIndex2) ).

fof(bitBlastConstant_390,axiom,
    b110(bitIndex1) ).

fof(bitBlastConstant_389,axiom,
    ~ b110(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_927,axiom,
    ! [VarCurr] :
      ( v4976(VarCurr)
    <=> ( v4977(VarCurr)
        | v4982(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_309,axiom,
    ! [VarCurr] :
      ( v4982(VarCurr)
    <=> ( ( v4965(VarCurr,bitIndex2)
        <=> $true )
        & ( v4965(VarCurr,bitIndex1)
        <=> $false )
        & ( v4965(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_926,axiom,
    ! [VarCurr] :
      ( v4977(VarCurr)
    <=> ( v4978(VarCurr)
        | v4981(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_308,axiom,
    ! [VarCurr] :
      ( v4981(VarCurr)
    <=> ( ( v4965(VarCurr,bitIndex2)
        <=> $true )
        & ( v4965(VarCurr,bitIndex1)
        <=> $false )
        & ( v4965(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_925,axiom,
    ! [VarCurr] :
      ( v4978(VarCurr)
    <=> ( v4979(VarCurr)
        | v4980(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_307,axiom,
    ! [VarCurr] :
      ( v4980(VarCurr)
    <=> ( ( v4965(VarCurr,bitIndex2)
        <=> $false )
        & ( v4965(VarCurr,bitIndex1)
        <=> $true )
        & ( v4965(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_306,axiom,
    ! [VarCurr] :
      ( v4979(VarCurr)
    <=> ( ( v4965(VarCurr,bitIndex2)
        <=> $false )
        & ( v4965(VarCurr,bitIndex1)
        <=> $false )
        & ( v4965(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_305,axiom,
    ! [VarCurr] :
      ( v4974(VarCurr)
    <=> ( ( v4965(VarCurr,bitIndex2)
        <=> $false )
        & ( v4965(VarCurr,bitIndex1)
        <=> $true )
        & ( v4965(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_304,axiom,
    ! [VarCurr] :
      ( v4971(VarCurr)
    <=> ( v4960(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_303,axiom,
    ! [VarCurr] :
      ( v4970(VarCurr)
    <=> ( v4960(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_302,axiom,
    ! [VarCurr] :
      ( v4968(VarCurr)
    <=> ( ( v4958(VarCurr,bitIndex2)
        <=> $false )
        & ( v4958(VarCurr,bitIndex1)
        <=> $false )
        & ( v4958(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeUnaryOperator_376,axiom,
    ! [VarCurr] :
      ( ~ v4960(VarCurr)
    <=> v4962(VarCurr) ) ).

fof(addAssignment_1375,axiom,
    ! [VarCurr] :
      ( v4952(VarCurr)
    <=> v53(VarCurr) ) ).

fof(addAssignment_1374,axiom,
    ! [VarCurr] :
      ( v4940(VarCurr)
    <=> v4942(VarCurr) ) ).

fof(addAssignment_1373,axiom,
    ! [VarCurr] :
      ( v4942(VarCurr)
    <=> v53(VarCurr) ) ).

fof(addAssignment_1372,axiom,
    ! [VarCurr] :
      ( v4935(VarCurr)
    <=> v4937(VarCurr) ) ).

fof(addAssignment_1371,axiom,
    ! [VarCurr] :
      ( v4937(VarCurr)
    <=> v172(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_83,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4908(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v4699(VarNext,B)
            <=> v4699(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_94,axiom,
    ! [VarNext] :
      ( v4908(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v4699(VarNext,B)
          <=> v4919(VarNext,B) ) ) ) ).

fof(addAssignment_1370,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v4919(VarNext,B)
          <=> v4917(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_127,axiom,
    ! [VarCurr] :
      ( ~ v4686(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4917(VarCurr,B)
          <=> v4701(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_129,axiom,
    ! [VarCurr] :
      ( v4686(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4917(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_924,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4908(VarNext)
      <=> ( v4909(VarNext)
          & v4916(VarNext) ) ) ) ).

fof(addAssignment_1369,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4916(VarNext)
      <=> v4914(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_923,axiom,
    ! [VarCurr] :
      ( v4914(VarCurr)
    <=> ( v67(VarCurr)
        | v4686(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_922,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4909(VarNext)
      <=> ( v4911(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_375,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4911(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignmentInitValueVector_17,axiom,
    ! [B] :
      ( range_4_0(B)
     => ( v4699(constB0,B)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_42,axiom,
    ! [VarCurr] :
      ( ( ~ v4898(VarCurr)
        & ~ v4901(VarCurr) )
     => ! [B] :
          ( range_4_0(B)
         => ( v4701(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_101,axiom,
    ! [VarCurr] :
      ( v4901(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4701(VarCurr,B)
          <=> v4703(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_95,axiom,
    ! [VarCurr] :
      ( v4898(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4701(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_921,axiom,
    ! [VarCurr] :
      ( v4901(VarCurr)
    <=> ( v4902(VarCurr)
        | v4905(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_301,axiom,
    ! [VarCurr] :
      ( v4905(VarCurr)
    <=> ( ( v3194(VarCurr,bitIndex2)
        <=> $true )
        & ( v3194(VarCurr,bitIndex1)
        <=> $false )
        & ( v3194(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_920,axiom,
    ! [VarCurr] :
      ( v4902(VarCurr)
    <=> ( v4903(VarCurr)
        | v4904(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_300,axiom,
    ! [VarCurr] :
      ( v4904(VarCurr)
    <=> ( ( v3194(VarCurr,bitIndex2)
        <=> $false )
        & ( v3194(VarCurr,bitIndex1)
        <=> $true )
        & ( v3194(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_299,axiom,
    ! [VarCurr] :
      ( v4903(VarCurr)
    <=> ( ( v3194(VarCurr,bitIndex2)
        <=> $false )
        & ( v3194(VarCurr,bitIndex1)
        <=> $false )
        & ( v3194(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_919,axiom,
    ! [VarCurr] :
      ( v4898(VarCurr)
    <=> ( v4899(VarCurr)
        | v4900(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_298,axiom,
    ! [VarCurr] :
      ( v4900(VarCurr)
    <=> ( ( v3194(VarCurr,bitIndex2)
        <=> $true )
        & ( v3194(VarCurr,bitIndex1)
        <=> $false )
        & ( v3194(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_297,axiom,
    ! [VarCurr] :
      ( v4899(VarCurr)
    <=> ( ( v3194(VarCurr,bitIndex2)
        <=> $false )
        & ( v3194(VarCurr,bitIndex1)
        <=> $true )
        & ( v3194(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1368,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v4703(VarCurr,B)
      <=> v4705(VarCurr,B) ) ) ).

fof(addAssignment_1367,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v4705(VarCurr,B)
      <=> v4707(VarCurr,B) ) ) ).

fof(addAssignment_1366,axiom,
    ! [VarCurr] :
      ( ( v4707(VarCurr,bitIndex4)
      <=> v4709(VarCurr,bitIndex19) )
      & ( v4707(VarCurr,bitIndex3)
      <=> v4709(VarCurr,bitIndex18) )
      & ( v4707(VarCurr,bitIndex2)
      <=> v4709(VarCurr,bitIndex17) )
      & ( v4707(VarCurr,bitIndex1)
      <=> v4709(VarCurr,bitIndex16) )
      & ( v4707(VarCurr,bitIndex0)
      <=> v4709(VarCurr,bitIndex15) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_82,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4867(VarNext)
       => ! [B] :
            ( range_19_15(B)
           => ( v4709(VarNext,B)
            <=> v4709(VarCurr,B) ) ) ) ) ).

fof(range_axiom_37,axiom,
    ! [B] :
      ( range_19_15(B)
    <=> ( $false
        | bitIndex15 = B
        | bitIndex16 = B
        | bitIndex17 = B
        | bitIndex18 = B
        | bitIndex19 = B ) ) ).

fof(addCaseBooleanConditionShiftedRanges0_4,axiom,
    ! [VarNext] :
      ( v4867(VarNext)
     => ( ( v4709(VarNext,bitIndex19)
        <=> v4893(VarNext,bitIndex4) )
        & ( v4709(VarNext,bitIndex18)
        <=> v4893(VarNext,bitIndex3) )
        & ( v4709(VarNext,bitIndex17)
        <=> v4893(VarNext,bitIndex2) )
        & ( v4709(VarNext,bitIndex16)
        <=> v4893(VarNext,bitIndex1) )
        & ( v4709(VarNext,bitIndex15)
        <=> v4893(VarNext,bitIndex0) ) ) ) ).

fof(addAssignment_1365,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v4893(VarNext,B)
          <=> v4891(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_100,axiom,
    ! [VarCurr] :
      ( ~ v4830(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4891(VarCurr,B)
          <=> v4894(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_94,axiom,
    ! [VarCurr] :
      ( v4830(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4891(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_41,axiom,
    ! [VarCurr] :
      ( ( ~ v4880(VarCurr)
        & ~ v4882(VarCurr) )
     => ! [B] :
          ( range_4_0(B)
         => ( v4894(VarCurr,B)
          <=> v4859(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_99,axiom,
    ! [VarCurr] :
      ( v4882(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4894(VarCurr,B)
          <=> v4852(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0_5,axiom,
    ! [VarCurr] :
      ( v4880(VarCurr)
     => ( ( v4894(VarCurr,bitIndex4)
        <=> v4709(VarCurr,bitIndex14) )
        & ( v4894(VarCurr,bitIndex3)
        <=> v4709(VarCurr,bitIndex13) )
        & ( v4894(VarCurr,bitIndex2)
        <=> v4709(VarCurr,bitIndex12) )
        & ( v4894(VarCurr,bitIndex1)
        <=> v4709(VarCurr,bitIndex11) )
        & ( v4894(VarCurr,bitIndex0)
        <=> v4709(VarCurr,bitIndex10) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_918,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4867(VarNext)
      <=> ( v4868(VarNext)
          & v4875(VarNext) ) ) ) ).

fof(addAssignment_1364,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4875(VarNext)
      <=> v4873(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_917,axiom,
    ! [VarCurr] :
      ( v4873(VarCurr)
    <=> ( v4876(VarCurr)
        & v4887(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_916,axiom,
    ! [VarCurr] :
      ( v4887(VarCurr)
    <=> ( v4888(VarCurr)
        | v4830(VarCurr) ) ) ).

fof(writeUnaryOperator_374,axiom,
    ! [VarCurr] :
      ( ~ v4888(VarCurr)
    <=> v4889(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_296,axiom,
    ! [VarCurr] :
      ( v4889(VarCurr)
    <=> ( ( v4890(VarCurr,bitIndex1)
        <=> $false )
        & ( v4890(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1363,axiom,
    ! [VarCurr] :
      ( v4890(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_1362,axiom,
    ! [VarCurr] :
      ( v4890(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_915,axiom,
    ! [VarCurr] :
      ( v4876(VarCurr)
    <=> ( v4830(VarCurr)
        | v4877(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_914,axiom,
    ! [VarCurr] :
      ( v4877(VarCurr)
    <=> ( v4878(VarCurr)
        & v4886(VarCurr) ) ) ).

fof(writeUnaryOperator_373,axiom,
    ! [VarCurr] :
      ( ~ v4886(VarCurr)
    <=> v4830(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_913,axiom,
    ! [VarCurr] :
      ( v4878(VarCurr)
    <=> ( v4879(VarCurr)
        | v4884(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_295,axiom,
    ! [VarCurr] :
      ( v4884(VarCurr)
    <=> ( ( v4885(VarCurr,bitIndex1)
        <=> $true )
        & ( v4885(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1361,axiom,
    ! [VarCurr] :
      ( v4885(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_1360,axiom,
    ! [VarCurr] :
      ( v4885(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_912,axiom,
    ! [VarCurr] :
      ( v4879(VarCurr)
    <=> ( v4880(VarCurr)
        | v4882(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_294,axiom,
    ! [VarCurr] :
      ( v4882(VarCurr)
    <=> ( ( v4883(VarCurr,bitIndex1)
        <=> $true )
        & ( v4883(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1359,axiom,
    ! [VarCurr] :
      ( v4883(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_1358,axiom,
    ! [VarCurr] :
      ( v4883(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_293,axiom,
    ! [VarCurr] :
      ( v4880(VarCurr)
    <=> ( ( v4881(VarCurr,bitIndex1)
        <=> $false )
        & ( v4881(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1357,axiom,
    ! [VarCurr] :
      ( v4881(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_1356,axiom,
    ! [VarCurr] :
      ( v4881(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_911,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4868(VarNext)
      <=> ( v4870(VarNext)
          & v2600(VarNext) ) ) ) ).

fof(writeUnaryOperator_372,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4870(VarNext)
      <=> v2607(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_126,axiom,
    ! [VarCurr] :
      ( ~ v4861(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4859(VarCurr,B)
          <=> v4863(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_128,axiom,
    ! [VarCurr] :
      ( v4861(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4859(VarCurr,B)
          <=> v4762(VarCurr,B) ) ) ) ).

fof(addAssignment_1355,axiom,
    ! [VarCurr] :
      ( ( v4863(VarCurr,bitIndex4)
      <=> v4709(VarCurr,bitIndex14) )
      & ( v4863(VarCurr,bitIndex3)
      <=> v4709(VarCurr,bitIndex13) )
      & ( v4863(VarCurr,bitIndex2)
      <=> v4709(VarCurr,bitIndex12) )
      & ( v4863(VarCurr,bitIndex1)
      <=> v4709(VarCurr,bitIndex11) )
      & ( v4863(VarCurr,bitIndex0)
      <=> v4709(VarCurr,bitIndex10) ) ) ).

fof(addAssignment_1354,axiom,
    ! [VarCurr] :
      ( v4861(VarCurr)
    <=> v4715(VarCurr,bitIndex1) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_125,axiom,
    ! [VarCurr] :
      ( ~ v4854(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4852(VarCurr,B)
          <=> v4856(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_127,axiom,
    ! [VarCurr] :
      ( v4854(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4852(VarCurr,B)
          <=> v4762(VarCurr,B) ) ) ) ).

fof(addAssignment_1353,axiom,
    ! [VarCurr] :
      ( ( v4856(VarCurr,bitIndex4)
      <=> v4709(VarCurr,bitIndex19) )
      & ( v4856(VarCurr,bitIndex3)
      <=> v4709(VarCurr,bitIndex18) )
      & ( v4856(VarCurr,bitIndex2)
      <=> v4709(VarCurr,bitIndex17) )
      & ( v4856(VarCurr,bitIndex1)
      <=> v4709(VarCurr,bitIndex16) )
      & ( v4856(VarCurr,bitIndex0)
      <=> v4709(VarCurr,bitIndex15) ) ) ).

fof(addAssignment_1352,axiom,
    ! [VarCurr] :
      ( v4854(VarCurr)
    <=> v4715(VarCurr,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_81,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4820(VarNext)
       => ! [B] :
            ( range_14_10(B)
           => ( v4709(VarNext,B)
            <=> v4709(VarCurr,B) ) ) ) ) ).

fof(range_axiom_36,axiom,
    ! [B] :
      ( range_14_10(B)
    <=> ( $false
        | bitIndex10 = B
        | bitIndex11 = B
        | bitIndex12 = B
        | bitIndex13 = B
        | bitIndex14 = B ) ) ).

fof(addCaseBooleanConditionShiftedRanges0_3,axiom,
    ! [VarNext] :
      ( v4820(VarNext)
     => ( ( v4709(VarNext,bitIndex14)
        <=> v4847(VarNext,bitIndex4) )
        & ( v4709(VarNext,bitIndex13)
        <=> v4847(VarNext,bitIndex3) )
        & ( v4709(VarNext,bitIndex12)
        <=> v4847(VarNext,bitIndex2) )
        & ( v4709(VarNext,bitIndex11)
        <=> v4847(VarNext,bitIndex1) )
        & ( v4709(VarNext,bitIndex10)
        <=> v4847(VarNext,bitIndex0) ) ) ) ).

fof(addAssignment_1351,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v4847(VarNext,B)
          <=> v4845(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_98,axiom,
    ! [VarCurr] :
      ( ~ v4830(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4845(VarCurr,B)
          <=> v4848(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_93,axiom,
    ! [VarCurr] :
      ( v4830(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4845(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_40,axiom,
    ! [VarCurr] :
      ( ( ~ v4834(VarCurr)
        & ~ v4836(VarCurr) )
     => ! [B] :
          ( range_4_0(B)
         => ( v4848(VarCurr,B)
          <=> v4812(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_97,axiom,
    ! [VarCurr] :
      ( v4836(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4848(VarCurr,B)
          <=> v4711(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0_4,axiom,
    ! [VarCurr] :
      ( v4834(VarCurr)
     => ( ( v4848(VarCurr,bitIndex4)
        <=> v4709(VarCurr,bitIndex9) )
        & ( v4848(VarCurr,bitIndex3)
        <=> v4709(VarCurr,bitIndex8) )
        & ( v4848(VarCurr,bitIndex2)
        <=> v4709(VarCurr,bitIndex7) )
        & ( v4848(VarCurr,bitIndex1)
        <=> v4709(VarCurr,bitIndex6) )
        & ( v4848(VarCurr,bitIndex0)
        <=> v4709(VarCurr,bitIndex5) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_910,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4820(VarNext)
      <=> ( v4821(VarNext)
          & v4828(VarNext) ) ) ) ).

fof(addAssignment_1350,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4828(VarNext)
      <=> v4826(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_909,axiom,
    ! [VarCurr] :
      ( v4826(VarCurr)
    <=> ( v4829(VarCurr)
        & v4841(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_908,axiom,
    ! [VarCurr] :
      ( v4841(VarCurr)
    <=> ( v4842(VarCurr)
        | v4830(VarCurr) ) ) ).

fof(writeUnaryOperator_371,axiom,
    ! [VarCurr] :
      ( ~ v4842(VarCurr)
    <=> v4843(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_292,axiom,
    ! [VarCurr] :
      ( v4843(VarCurr)
    <=> ( ( v4844(VarCurr,bitIndex1)
        <=> $false )
        & ( v4844(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1349,axiom,
    ! [VarCurr] :
      ( v4844(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_1348,axiom,
    ! [VarCurr] :
      ( v4844(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_907,axiom,
    ! [VarCurr] :
      ( v4829(VarCurr)
    <=> ( v4830(VarCurr)
        | v4831(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_906,axiom,
    ! [VarCurr] :
      ( v4831(VarCurr)
    <=> ( v4832(VarCurr)
        & v4840(VarCurr) ) ) ).

fof(writeUnaryOperator_370,axiom,
    ! [VarCurr] :
      ( ~ v4840(VarCurr)
    <=> v4830(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_905,axiom,
    ! [VarCurr] :
      ( v4832(VarCurr)
    <=> ( v4833(VarCurr)
        | v4838(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_291,axiom,
    ! [VarCurr] :
      ( v4838(VarCurr)
    <=> ( ( v4839(VarCurr,bitIndex1)
        <=> $true )
        & ( v4839(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1347,axiom,
    ! [VarCurr] :
      ( v4839(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_1346,axiom,
    ! [VarCurr] :
      ( v4839(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_904,axiom,
    ! [VarCurr] :
      ( v4833(VarCurr)
    <=> ( v4834(VarCurr)
        | v4836(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_290,axiom,
    ! [VarCurr] :
      ( v4836(VarCurr)
    <=> ( ( v4837(VarCurr,bitIndex1)
        <=> $true )
        & ( v4837(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1345,axiom,
    ! [VarCurr] :
      ( v4837(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_1344,axiom,
    ! [VarCurr] :
      ( v4837(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_289,axiom,
    ! [VarCurr] :
      ( v4834(VarCurr)
    <=> ( ( v4835(VarCurr,bitIndex1)
        <=> $false )
        & ( v4835(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1343,axiom,
    ! [VarCurr] :
      ( v4835(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_1342,axiom,
    ! [VarCurr] :
      ( v4835(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(writeUnaryOperator_369,axiom,
    ! [VarCurr] :
      ( ~ v4830(VarCurr)
    <=> v2570(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_903,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4821(VarNext)
      <=> ( v4822(VarNext)
          & v2600(VarNext) ) ) ) ).

fof(writeUnaryOperator_368,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4822(VarNext)
      <=> v2607(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_124,axiom,
    ! [VarCurr] :
      ( ~ v4814(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4812(VarCurr,B)
          <=> v4816(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_126,axiom,
    ! [VarCurr] :
      ( v4814(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4812(VarCurr,B)
          <=> v4762(VarCurr,B) ) ) ) ).

fof(addAssignment_1341,axiom,
    ! [VarCurr] :
      ( ( v4816(VarCurr,bitIndex4)
      <=> v4709(VarCurr,bitIndex9) )
      & ( v4816(VarCurr,bitIndex3)
      <=> v4709(VarCurr,bitIndex8) )
      & ( v4816(VarCurr,bitIndex2)
      <=> v4709(VarCurr,bitIndex7) )
      & ( v4816(VarCurr,bitIndex1)
      <=> v4709(VarCurr,bitIndex6) )
      & ( v4816(VarCurr,bitIndex0)
      <=> v4709(VarCurr,bitIndex5) ) ) ).

fof(addAssignment_1340,axiom,
    ! [VarCurr] :
      ( v4814(VarCurr)
    <=> v4715(VarCurr,bitIndex2) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_123,axiom,
    ! [VarCurr] :
      ( ~ v4713(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4711(VarCurr,B)
          <=> v4809(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_125,axiom,
    ! [VarCurr] :
      ( v4713(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4711(VarCurr,B)
          <=> v4762(VarCurr,B) ) ) ) ).

fof(addAssignment_1339,axiom,
    ! [VarCurr] :
      ( ( v4809(VarCurr,bitIndex4)
      <=> v4709(VarCurr,bitIndex14) )
      & ( v4809(VarCurr,bitIndex3)
      <=> v4709(VarCurr,bitIndex13) )
      & ( v4809(VarCurr,bitIndex2)
      <=> v4709(VarCurr,bitIndex12) )
      & ( v4809(VarCurr,bitIndex1)
      <=> v4709(VarCurr,bitIndex11) )
      & ( v4809(VarCurr,bitIndex0)
      <=> v4709(VarCurr,bitIndex10) ) ) ).

fof(addAssignmentInitValueVector_16,axiom,
    ( ( v4709(constB0,bitIndex19)
    <=> $false )
    & ( v4709(constB0,bitIndex18)
    <=> $false )
    & ( v4709(constB0,bitIndex17)
    <=> $false )
    & ( v4709(constB0,bitIndex16)
    <=> $false )
    & ( v4709(constB0,bitIndex15)
    <=> $false ) ) ).

fof(addAssignment_1338,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v4762(VarCurr,B)
      <=> v4764(VarCurr,B) ) ) ).

fof(addAssignment_1337,axiom,
    ! [VarCurr] :
      ( ( v4764(VarCurr,bitIndex4)
      <=> v3269(VarCurr,bitIndex9) )
      & ( v4764(VarCurr,bitIndex3)
      <=> v3269(VarCurr,bitIndex8) )
      & ( v4764(VarCurr,bitIndex2)
      <=> v3269(VarCurr,bitIndex7) )
      & ( v4764(VarCurr,bitIndex1)
      <=> v3269(VarCurr,bitIndex6) )
      & ( v4764(VarCurr,bitIndex0)
      <=> v3269(VarCurr,bitIndex5) ) ) ).

fof(addAssignment_1336,axiom,
    ! [VarCurr,B] :
      ( range_9_5(B)
     => ( v3269(VarCurr,B)
      <=> v3271(VarCurr,B) ) ) ).

fof(addAssignment_1335,axiom,
    ! [VarCurr,B] :
      ( range_9_5(B)
     => ( v3271(VarCurr,B)
      <=> v3273(VarCurr,B) ) ) ).

fof(addAssignment_1334,axiom,
    ! [VarCurr,B] :
      ( range_9_5(B)
     => ( v3273(VarCurr,B)
      <=> v3275(VarCurr,B) ) ) ).

fof(addAssignment_1333,axiom,
    ! [VarCurr,B] :
      ( range_9_5(B)
     => ( v3275(VarCurr,B)
      <=> v3277(VarCurr,B) ) ) ).

fof(addAssignment_1332,axiom,
    ! [VarCurr,B] :
      ( range_9_5(B)
     => ( v3277(VarCurr,B)
      <=> v3279(VarCurr,B) ) ) ).

fof(addAssignment_1331,axiom,
    ! [VarCurr,B] :
      ( range_9_5(B)
     => ( v3279(VarCurr,B)
      <=> v3281(VarCurr,B) ) ) ).

fof(addAssignment_1330,axiom,
    ! [VarCurr,B] :
      ( range_9_5(B)
     => ( v3281(VarCurr,B)
      <=> v4121(VarCurr,B) ) ) ).

fof(range_axiom_35,axiom,
    ! [B] :
      ( range_9_5(B)
    <=> ( $false
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B ) ) ).

fof(addCaseBooleanConditionEqualRanges1_80,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4790(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v4136(VarNext,B)
            <=> v4136(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_93,axiom,
    ! [VarNext] :
      ( v4790(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v4136(VarNext,B)
          <=> v4805(VarNext,B) ) ) ) ).

fof(addAssignment_1329,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v4805(VarNext,B)
          <=> v4803(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_96,axiom,
    ! [VarCurr] :
      ( ~ v4799(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4803(VarCurr,B)
          <=> v4773(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_92,axiom,
    ! [VarCurr] :
      ( v4799(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v4803(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_902,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4790(VarNext)
      <=> ( v4791(VarNext)
          & v4798(VarNext) ) ) ) ).

fof(addAssignment_1328,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4798(VarNext)
      <=> v4796(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_901,axiom,
    ! [VarCurr] :
      ( v4796(VarCurr)
    <=> ( v4799(VarCurr)
        | v4800(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_900,axiom,
    ! [VarCurr] :
      ( v4800(VarCurr)
    <=> ( v4801(VarCurr)
        & v4802(VarCurr) ) ) ).

fof(writeUnaryOperator_367,axiom,
    ! [VarCurr] :
      ( ~ v4802(VarCurr)
    <=> v4799(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_899,axiom,
    ! [VarCurr] :
      ( v4801(VarCurr)
    <=> ( v4766(VarCurr)
        | v3287(VarCurr) ) ) ).

fof(writeUnaryOperator_366,axiom,
    ! [VarCurr] :
      ( ~ v4799(VarCurr)
    <=> v3285(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_898,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4791(VarNext)
      <=> ( v4792(VarNext)
          & v4099(VarNext) ) ) ) ).

fof(writeUnaryOperator_365,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4792(VarNext)
      <=> v4106(VarNext) ) ) ).

fof(addAssignment_1327,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v4773(VarCurr,B)
      <=> v4775(VarCurr,B) ) ) ).

fof(addAssignment_1326,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v4775(VarCurr,B)
      <=> v4777(VarCurr,B) ) ) ).

fof(addAssignment_1325,axiom,
    ! [VarCurr] :
      ( ( v4777(VarCurr,bitIndex4)
      <=> v4779(VarCurr,bitIndex30) )
      & ( v4777(VarCurr,bitIndex3)
      <=> v4779(VarCurr,bitIndex29) )
      & ( v4777(VarCurr,bitIndex2)
      <=> v4779(VarCurr,bitIndex28) )
      & ( v4777(VarCurr,bitIndex1)
      <=> v4779(VarCurr,bitIndex27) )
      & ( v4777(VarCurr,bitIndex0)
      <=> v4779(VarCurr,bitIndex26) ) ) ).

fof(addAssignment_1324,axiom,
    ! [VarCurr,B] :
      ( range_30_26(B)
     => ( v4779(VarCurr,B)
      <=> v4781(VarCurr,B) ) ) ).

fof(addAssignment_1323,axiom,
    ! [VarCurr,B] :
      ( range_30_26(B)
     => ( v4781(VarCurr,B)
      <=> v4783(VarCurr,B) ) ) ).

fof(addAssignment_1322,axiom,
    ! [VarCurr,B] :
      ( range_30_26(B)
     => ( v4783(VarCurr,B)
      <=> v4785(VarCurr,B) ) ) ).

fof(addAssignment_1321,axiom,
    ! [VarCurr,B] :
      ( range_30_26(B)
     => ( v4785(VarCurr,B)
      <=> v4787(VarCurr,B) ) ) ).

fof(range_axiom_34,axiom,
    ! [B] :
      ( range_30_26(B)
    <=> ( $false
        | bitIndex26 = B
        | bitIndex27 = B
        | bitIndex28 = B
        | bitIndex29 = B
        | bitIndex30 = B ) ) ).

fof(addAssignment_1320,axiom,
    ! [VarCurr] :
      ( v4766(VarCurr)
    <=> v4768(VarCurr) ) ).

fof(addAssignment_1319,axiom,
    ! [VarCurr] :
      ( v4768(VarCurr)
    <=> v4770(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_131,axiom,
    ! [VarCurr] :
      ( v4770(VarCurr)
    <=> ( v622(VarCurr)
        & v756(VarCurr,bitIndex2) ) ) ).

fof(addAssignment_1318,axiom,
    ! [VarCurr] :
      ( v4713(VarCurr)
    <=> v4715(VarCurr,bitIndex2) ) ).

fof(addAssignment_1317,axiom,
    ! [VarCurr] :
      ( v4715(VarCurr,bitIndex2)
    <=> v4729(VarCurr,bitIndex2) ) ).

fof(addAssignment_1316,axiom,
    ! [VarNext] :
      ( v2636(VarNext,bitIndex1)
    <=> v4754(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_79,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4755(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v4754(VarNext,B)
            <=> v2636(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_92,axiom,
    ! [VarNext] :
      ( v4755(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v4754(VarNext,B)
          <=> v4726(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_897,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4755(VarNext)
      <=> v4756(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_896,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4756(VarNext)
      <=> ( v4758(VarNext)
          & v2600(VarNext) ) ) ) ).

fof(writeUnaryOperator_364,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4758(VarNext)
      <=> v2607(VarNext) ) ) ).

fof(addAssignment_1315,axiom,
    ! [VarCurr] :
      ( v4715(VarCurr,bitIndex1)
    <=> v4729(VarCurr,bitIndex1) ) ).

fof(addAssignment_1314,axiom,
    ! [VarNext] :
      ( v2636(VarNext,bitIndex0)
    <=> v4746(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_78,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4747(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v4746(VarNext,B)
            <=> v2636(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_91,axiom,
    ! [VarNext] :
      ( v4747(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v4746(VarNext,B)
          <=> v4726(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_895,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4747(VarNext)
      <=> v4748(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_894,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4748(VarNext)
      <=> ( v4750(VarNext)
          & v2600(VarNext) ) ) ) ).

fof(writeUnaryOperator_363,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4750(VarNext)
      <=> v2607(VarNext) ) ) ).

fof(addAssignment_1313,axiom,
    ! [VarCurr] :
      ( v4715(VarCurr,bitIndex0)
    <=> v4729(VarCurr,bitIndex0) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_122,axiom,
    ! [VarCurr] :
      ( ~ v4730(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4729(VarCurr,B)
          <=> v4732(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_124,axiom,
    ! [VarCurr] :
      ( v4730(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4729(VarCurr,B)
          <=> v4731(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_18,axiom,
    ! [VarCurr] :
      ( ( ~ v4733(VarCurr)
        & ~ v4735(VarCurr)
        & ~ v4739(VarCurr) )
     => ! [B] :
          ( range_6_0(B)
         => ( v4732(VarCurr,B)
          <=> v2636(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_39,axiom,
    ! [VarCurr] :
      ( v4739(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4732(VarCurr,B)
          <=> v4741(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_95,axiom,
    ! [VarCurr] :
      ( v4735(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4732(VarCurr,B)
          <=> v4737(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_91,axiom,
    ! [VarCurr] :
      ( v4733(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4732(VarCurr,B)
          <=> v2636(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_288,axiom,
    ! [VarCurr] :
      ( v4743(VarCurr)
    <=> ( ( v4744(VarCurr,bitIndex1)
        <=> $true )
        & ( v4744(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1312,axiom,
    ! [VarCurr] :
      ( v4744(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_1311,axiom,
    ! [VarCurr] :
      ( v4744(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(addAssignment_1310,axiom,
    ! [VarCurr] :
      ( v4741(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_1309,axiom,
    ! [VarCurr] :
      ( ( v4741(VarCurr,bitIndex6)
      <=> v2636(VarCurr,bitIndex5) )
      & ( v4741(VarCurr,bitIndex5)
      <=> v2636(VarCurr,bitIndex4) )
      & ( v4741(VarCurr,bitIndex4)
      <=> v2636(VarCurr,bitIndex3) )
      & ( v4741(VarCurr,bitIndex3)
      <=> v2636(VarCurr,bitIndex2) )
      & ( v4741(VarCurr,bitIndex2)
      <=> v2636(VarCurr,bitIndex1) )
      & ( v4741(VarCurr,bitIndex1)
      <=> v2636(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_287,axiom,
    ! [VarCurr] :
      ( v4739(VarCurr)
    <=> ( ( v4740(VarCurr,bitIndex1)
        <=> $true )
        & ( v4740(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1308,axiom,
    ! [VarCurr] :
      ( v4740(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_1307,axiom,
    ! [VarCurr] :
      ( v4740(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(addAssignment_1306,axiom,
    ! [VarCurr] :
      ( ( v4737(VarCurr,bitIndex5)
      <=> v2636(VarCurr,bitIndex6) )
      & ( v4737(VarCurr,bitIndex4)
      <=> v2636(VarCurr,bitIndex5) )
      & ( v4737(VarCurr,bitIndex3)
      <=> v2636(VarCurr,bitIndex4) )
      & ( v4737(VarCurr,bitIndex2)
      <=> v2636(VarCurr,bitIndex3) )
      & ( v4737(VarCurr,bitIndex1)
      <=> v2636(VarCurr,bitIndex2) )
      & ( v4737(VarCurr,bitIndex0)
      <=> v2636(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1305,axiom,
    ! [VarCurr] :
      ( v4737(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_286,axiom,
    ! [VarCurr] :
      ( v4735(VarCurr)
    <=> ( ( v4736(VarCurr,bitIndex1)
        <=> $false )
        & ( v4736(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1304,axiom,
    ! [VarCurr] :
      ( v4736(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_1303,axiom,
    ! [VarCurr] :
      ( v4736(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_285,axiom,
    ! [VarCurr] :
      ( v4733(VarCurr)
    <=> ( ( v4734(VarCurr,bitIndex1)
        <=> $false )
        & ( v4734(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1302,axiom,
    ! [VarCurr] :
      ( v4734(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_1301,axiom,
    ! [VarCurr] :
      ( v4734(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(addAssignment_1300,axiom,
    ! [VarCurr] :
      ( v4731(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_1299,axiom,
    ! [VarCurr,B] :
      ( range_6_1(B)
     => ( v4731(VarCurr,B)
      <=> v2634(VarCurr,B) ) ) ).

fof(writeUnaryOperator_362,axiom,
    ! [VarCurr] :
      ( ~ v4730(VarCurr)
    <=> v2570(VarCurr) ) ).

fof(addAssignment_1298,axiom,
    ! [VarCurr] :
      ( v2634(VarCurr,bitIndex1)
    <=> v2635(VarCurr,bitIndex1) ) ).

fof(addAssignment_1297,axiom,
    ! [VarCurr] :
      ( v2634(VarCurr,bitIndex2)
    <=> v2635(VarCurr,bitIndex2) ) ).

fof(addAssignment_1296,axiom,
    ! [VarNext] :
      ( v2636(VarNext,bitIndex2)
    <=> v4717(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_77,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4718(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v4717(VarNext,B)
            <=> v2636(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_90,axiom,
    ! [VarNext] :
      ( v4718(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v4717(VarNext,B)
          <=> v4726(VarNext,B) ) ) ) ).

fof(addAssignment_1295,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v4726(VarNext,B)
          <=> v4724(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_121,axiom,
    ! [VarCurr] :
      ( ~ v2614(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4724(VarCurr,B)
          <=> v4715(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_123,axiom,
    ! [VarCurr] :
      ( v2614(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4724(VarCurr,B)
          <=> b0000001(B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_893,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4718(VarNext)
      <=> v4719(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_892,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4719(VarNext)
      <=> ( v4721(VarNext)
          & v2600(VarNext) ) ) ) ).

fof(writeUnaryOperator_361,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4721(VarNext)
      <=> v2607(VarNext) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_76,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4675(VarNext)
       => ! [B] :
            ( range_2_0(B)
           => ( v4672(VarNext,B)
            <=> v4672(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_89,axiom,
    ! [VarNext] :
      ( v4675(VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v4672(VarNext,B)
          <=> v4689(VarNext,B) ) ) ) ).

fof(addAssignment_1294,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v4689(VarNext,B)
          <=> v4687(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_120,axiom,
    ! [VarCurr] :
      ( ~ v4686(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v4687(VarCurr,B)
          <=> v3194(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_122,axiom,
    ! [VarCurr] :
      ( v4686(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v4687(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_891,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4675(VarNext)
      <=> ( v4676(VarNext)
          & v4685(VarNext) ) ) ) ).

fof(addAssignment_1293,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4685(VarNext)
      <=> v4683(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_890,axiom,
    ! [VarCurr] :
      ( v4683(VarCurr)
    <=> ( v67(VarCurr)
        | v4686(VarCurr) ) ) ).

fof(writeUnaryOperator_360,axiom,
    ! [VarCurr] :
      ( ~ v4686(VarCurr)
    <=> v51(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_889,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4676(VarNext)
      <=> ( v4677(VarNext)
          & v170(VarNext) ) ) ) ).

fof(writeUnaryOperator_359,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4677(VarNext)
      <=> v4679(VarNext) ) ) ).

fof(addAssignment_1292,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4679(VarNext)
      <=> v170(VarCurr) ) ) ).

fof(addAssignmentInitValueVector_15,axiom,
    ! [B] :
      ( range_2_0(B)
     => ( v4672(constB0,B)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_38,axiom,
    ! [VarCurr] :
      ( ( ~ v142(VarCurr)
        & ~ v143(VarCurr) )
     => ( v3192(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_94,axiom,
    ! [VarCurr] :
      ( v143(VarCurr)
     => ( v3192(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_90,axiom,
    ! [VarCurr] :
      ( v142(VarCurr)
     => ( v3192(VarCurr)
      <=> v4648(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_93,axiom,
    ! [VarCurr] :
      ( ~ v4649(VarCurr)
     => ( v4648(VarCurr)
      <=> v4651(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_89,axiom,
    ! [VarCurr] :
      ( v4649(VarCurr)
     => ( v4648(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_92,axiom,
    ! [VarCurr] :
      ( ~ v4652(VarCurr)
     => ( v4651(VarCurr)
      <=> v4656(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_88,axiom,
    ! [VarCurr] :
      ( v4652(VarCurr)
     => ( v4651(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_37,axiom,
    ! [VarCurr] :
      ( ( ~ v4657(VarCurr)
        & ~ v4662(VarCurr) )
     => ( v4656(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_91,axiom,
    ! [VarCurr] :
      ( v4662(VarCurr)
     => ( v4656(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_87,axiom,
    ! [VarCurr] :
      ( v4657(VarCurr)
     => ( v4656(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_888,axiom,
    ! [VarCurr] :
      ( v4662(VarCurr)
    <=> ( v4663(VarCurr)
        | v4664(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_284,axiom,
    ! [VarCurr] :
      ( v4664(VarCurr)
    <=> ( ( v3194(VarCurr,bitIndex2)
        <=> $false )
        & ( v3194(VarCurr,bitIndex1)
        <=> $true )
        & ( v3194(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_283,axiom,
    ! [VarCurr] :
      ( v4663(VarCurr)
    <=> ( ( v3194(VarCurr,bitIndex2)
        <=> $false )
        & ( v3194(VarCurr,bitIndex1)
        <=> $false )
        & ( v3194(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_887,axiom,
    ! [VarCurr] :
      ( v4657(VarCurr)
    <=> ( v4658(VarCurr)
        | v4661(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_282,axiom,
    ! [VarCurr] :
      ( v4661(VarCurr)
    <=> ( ( v3194(VarCurr,bitIndex2)
        <=> $true )
        & ( v3194(VarCurr,bitIndex1)
        <=> $false )
        & ( v3194(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_886,axiom,
    ! [VarCurr] :
      ( v4658(VarCurr)
    <=> ( v4659(VarCurr)
        | v4660(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_281,axiom,
    ! [VarCurr] :
      ( v4660(VarCurr)
    <=> ( ( v3194(VarCurr,bitIndex2)
        <=> $false )
        & ( v3194(VarCurr,bitIndex1)
        <=> $true )
        & ( v3194(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_280,axiom,
    ! [VarCurr] :
      ( v4659(VarCurr)
    <=> ( ( v3194(VarCurr,bitIndex2)
        <=> $true )
        & ( v3194(VarCurr,bitIndex1)
        <=> $false )
        & ( v3194(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_279,axiom,
    ! [VarCurr] :
      ( v4654(VarCurr)
    <=> ( v4655(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_885,axiom,
    ! [VarCurr] :
      ( v4655(VarCurr)
    <=> ( v65(VarCurr)
        | v2961(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_278,axiom,
    ! [VarCurr] :
      ( v4652(VarCurr)
    <=> ( v4653(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_884,axiom,
    ! [VarCurr] :
      ( v4653(VarCurr)
    <=> ( v65(VarCurr)
        | v2961(VarCurr) ) ) ).

fof(addAssignmentInitValueVector_14,axiom,
    ( v65(constB0)
  <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_277,axiom,
    ! [VarCurr] :
      ( v4650(VarCurr)
    <=> ( v74(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_276,axiom,
    ! [VarCurr] :
      ( v4649(VarCurr)
    <=> ( v74(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges4_2,axiom,
    ! [VarCurr] :
      ( ( ~ v4621(VarCurr)
        & ~ v4640(VarCurr)
        & ~ v4641(VarCurr)
        & ~ v4646(VarCurr) )
     => ! [B] :
          ( range_2_0(B)
         => ( v3194(VarCurr,B)
          <=> $true ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_17,axiom,
    ! [VarCurr] :
      ( v4646(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v3194(VarCurr,B)
          <=> b010(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_36,axiom,
    ! [VarCurr] :
      ( v4641(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v3194(VarCurr,B)
          <=> v4644(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_90,axiom,
    ! [VarCurr] :
      ( v4640(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v3194(VarCurr,B)
          <=> b100(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_86,axiom,
    ! [VarCurr] :
      ( v4621(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v3194(VarCurr,B)
          <=> b011(B) ) ) ) ).

fof(bitBlastConstant_388,axiom,
    ~ b011(bitIndex2) ).

fof(bitBlastConstant_387,axiom,
    b011(bitIndex1) ).

fof(bitBlastConstant_386,axiom,
    b011(bitIndex0) ).

fof(addBitVectorEqualityBitBlasted_275,axiom,
    ! [VarCurr] :
      ( v4646(VarCurr)
    <=> ( ( v3196(VarCurr,bitIndex6)
        <=> $true )
        & ( v3196(VarCurr,bitIndex5)
        <=> $false )
        & ( v3196(VarCurr,bitIndex4)
        <=> $false )
        & ( v3196(VarCurr,bitIndex3)
        <=> $true )
        & ( v3196(VarCurr,bitIndex2)
        <=> $false )
        & ( v3196(VarCurr,bitIndex1)
        <=> $true )
        & ( v3196(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_89,axiom,
    ! [VarCurr] :
      ( ~ v4645(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v4644(VarCurr,B)
          <=> b001(B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_85,axiom,
    ! [VarCurr] :
      ( v4645(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v4644(VarCurr,B)
          <=> b101(B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_274,axiom,
    ! [VarCurr] :
      ( v4645(VarCurr)
    <=> ( ( v4276(VarCurr,bitIndex2)
        <=> $false )
        & ( v4276(VarCurr,bitIndex1)
        <=> $false )
        & ( v4276(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_883,axiom,
    ! [VarCurr] :
      ( v4641(VarCurr)
    <=> ( v4642(VarCurr)
        | v4643(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_273,axiom,
    ! [VarCurr] :
      ( v4643(VarCurr)
    <=> ( ( v3196(VarCurr,bitIndex6)
        <=> $false )
        & ( v3196(VarCurr,bitIndex5)
        <=> $false )
        & ( v3196(VarCurr,bitIndex4)
        <=> $false )
        & ( v3196(VarCurr,bitIndex3)
        <=> $true )
        & ( v3196(VarCurr,bitIndex2)
        <=> $false )
        & ( v3196(VarCurr,bitIndex1)
        <=> $true )
        & ( v3196(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_272,axiom,
    ! [VarCurr] :
      ( v4642(VarCurr)
    <=> ( ( v3196(VarCurr,bitIndex6)
        <=> $false )
        & ( v3196(VarCurr,bitIndex5)
        <=> $false )
        & ( v3196(VarCurr,bitIndex4)
        <=> $false )
        & ( v3196(VarCurr,bitIndex3)
        <=> $true )
        & ( v3196(VarCurr,bitIndex2)
        <=> $false )
        & ( v3196(VarCurr,bitIndex1)
        <=> $true )
        & ( v3196(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_271,axiom,
    ! [VarCurr] :
      ( v4640(VarCurr)
    <=> ( ( v3196(VarCurr,bitIndex6)
        <=> $true )
        & ( v3196(VarCurr,bitIndex5)
        <=> $true )
        & ( v3196(VarCurr,bitIndex4)
        <=> $true )
        & ( v3196(VarCurr,bitIndex3)
        <=> $true )
        & ( v3196(VarCurr,bitIndex2)
        <=> $false )
        & ( v3196(VarCurr,bitIndex1)
        <=> $true )
        & ( v3196(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_882,axiom,
    ! [VarCurr] :
      ( v4621(VarCurr)
    <=> ( v4622(VarCurr)
        | v4639(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_270,axiom,
    ! [VarCurr] :
      ( v4639(VarCurr)
    <=> ( ( v3196(VarCurr,bitIndex6)
        <=> $true )
        & ( v3196(VarCurr,bitIndex5)
        <=> $false )
        & ( v3196(VarCurr,bitIndex4)
        <=> $false )
        & ( v3196(VarCurr,bitIndex3)
        <=> $false )
        & ( v3196(VarCurr,bitIndex2)
        <=> $true )
        & ( v3196(VarCurr,bitIndex1)
        <=> $false )
        & ( v3196(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_881,axiom,
    ! [VarCurr] :
      ( v4622(VarCurr)
    <=> ( v4623(VarCurr)
        | v4638(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_269,axiom,
    ! [VarCurr] :
      ( v4638(VarCurr)
    <=> ( ( v3196(VarCurr,bitIndex6)
        <=> $true )
        & ( v3196(VarCurr,bitIndex5)
        <=> $false )
        & ( v3196(VarCurr,bitIndex4)
        <=> $false )
        & ( v3196(VarCurr,bitIndex3)
        <=> $false )
        & ( v3196(VarCurr,bitIndex2)
        <=> $true )
        & ( v3196(VarCurr,bitIndex1)
        <=> $false )
        & ( v3196(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_880,axiom,
    ! [VarCurr] :
      ( v4623(VarCurr)
    <=> ( v4624(VarCurr)
        | v4637(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_268,axiom,
    ! [VarCurr] :
      ( v4637(VarCurr)
    <=> ( ( v3196(VarCurr,bitIndex6)
        <=> $true )
        & ( v3196(VarCurr,bitIndex5)
        <=> $false )
        & ( v3196(VarCurr,bitIndex4)
        <=> $false )
        & ( v3196(VarCurr,bitIndex3)
        <=> $false )
        & ( v3196(VarCurr,bitIndex2)
        <=> $false )
        & ( v3196(VarCurr,bitIndex1)
        <=> $true )
        & ( v3196(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_879,axiom,
    ! [VarCurr] :
      ( v4624(VarCurr)
    <=> ( v4625(VarCurr)
        | v4636(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_267,axiom,
    ! [VarCurr] :
      ( v4636(VarCurr)
    <=> ( ( v3196(VarCurr,bitIndex6)
        <=> $true )
        & ( v3196(VarCurr,bitIndex5)
        <=> $true )
        & ( v3196(VarCurr,bitIndex4)
        <=> $false )
        & ( v3196(VarCurr,bitIndex3)
        <=> $false )
        & ( v3196(VarCurr,bitIndex2)
        <=> $false )
        & ( v3196(VarCurr,bitIndex1)
        <=> $false )
        & ( v3196(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_878,axiom,
    ! [VarCurr] :
      ( v4625(VarCurr)
    <=> ( v4626(VarCurr)
        | v4635(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_266,axiom,
    ! [VarCurr] :
      ( v4635(VarCurr)
    <=> ( ( v3196(VarCurr,bitIndex6)
        <=> $true )
        & ( v3196(VarCurr,bitIndex5)
        <=> $false )
        & ( v3196(VarCurr,bitIndex4)
        <=> $false )
        & ( v3196(VarCurr,bitIndex3)
        <=> $false )
        & ( v3196(VarCurr,bitIndex2)
        <=> $false )
        & ( v3196(VarCurr,bitIndex1)
        <=> $false )
        & ( v3196(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_877,axiom,
    ! [VarCurr] :
      ( v4626(VarCurr)
    <=> ( v4627(VarCurr)
        | v4634(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_265,axiom,
    ! [VarCurr] :
      ( v4634(VarCurr)
    <=> ( ( v3196(VarCurr,bitIndex6)
        <=> $false )
        & ( v3196(VarCurr,bitIndex5)
        <=> $false )
        & ( v3196(VarCurr,bitIndex4)
        <=> $false )
        & ( v3196(VarCurr,bitIndex3)
        <=> $false )
        & ( v3196(VarCurr,bitIndex2)
        <=> $true )
        & ( v3196(VarCurr,bitIndex1)
        <=> $false )
        & ( v3196(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_876,axiom,
    ! [VarCurr] :
      ( v4627(VarCurr)
    <=> ( v4628(VarCurr)
        | v4633(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_264,axiom,
    ! [VarCurr] :
      ( v4633(VarCurr)
    <=> ( ( v3196(VarCurr,bitIndex6)
        <=> $false )
        & ( v3196(VarCurr,bitIndex5)
        <=> $false )
        & ( v3196(VarCurr,bitIndex4)
        <=> $false )
        & ( v3196(VarCurr,bitIndex3)
        <=> $false )
        & ( v3196(VarCurr,bitIndex2)
        <=> $true )
        & ( v3196(VarCurr,bitIndex1)
        <=> $false )
        & ( v3196(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_875,axiom,
    ! [VarCurr] :
      ( v4628(VarCurr)
    <=> ( v4629(VarCurr)
        | v4632(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_263,axiom,
    ! [VarCurr] :
      ( v4632(VarCurr)
    <=> ( ( v3196(VarCurr,bitIndex6)
        <=> $false )
        & ( v3196(VarCurr,bitIndex5)
        <=> $false )
        & ( v3196(VarCurr,bitIndex4)
        <=> $false )
        & ( v3196(VarCurr,bitIndex3)
        <=> $false )
        & ( v3196(VarCurr,bitIndex2)
        <=> $false )
        & ( v3196(VarCurr,bitIndex1)
        <=> $true )
        & ( v3196(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_874,axiom,
    ! [VarCurr] :
      ( v4629(VarCurr)
    <=> ( v4630(VarCurr)
        | v4631(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_262,axiom,
    ! [VarCurr] :
      ( v4631(VarCurr)
    <=> ( ( v3196(VarCurr,bitIndex6)
        <=> $false )
        & ( v3196(VarCurr,bitIndex5)
        <=> $true )
        & ( v3196(VarCurr,bitIndex4)
        <=> $false )
        & ( v3196(VarCurr,bitIndex3)
        <=> $false )
        & ( v3196(VarCurr,bitIndex2)
        <=> $false )
        & ( v3196(VarCurr,bitIndex1)
        <=> $false )
        & ( v3196(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_261,axiom,
    ! [VarCurr] :
      ( v4630(VarCurr)
    <=> ( ( v3196(VarCurr,bitIndex6)
        <=> $false )
        & ( v3196(VarCurr,bitIndex5)
        <=> $false )
        & ( v3196(VarCurr,bitIndex4)
        <=> $false )
        & ( v3196(VarCurr,bitIndex3)
        <=> $false )
        & ( v3196(VarCurr,bitIndex2)
        <=> $false )
        & ( v3196(VarCurr,bitIndex1)
        <=> $false )
        & ( v3196(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1291,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4276(VarCurr,B)
      <=> v4278(VarCurr,B) ) ) ).

fof(addAssignment_1290,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4278(VarCurr,B)
      <=> v4280(VarCurr,B) ) ) ).

fof(addAssignment_1289,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4280(VarCurr,B)
      <=> v4282(VarCurr,B) ) ) ).

fof(addAssignment_1288,axiom,
    ! [VarCurr] :
      ( ( v4282(VarCurr,bitIndex2)
      <=> v4284(VarCurr,bitIndex26) )
      & ( v4282(VarCurr,bitIndex1)
      <=> v4284(VarCurr,bitIndex25) )
      & ( v4282(VarCurr,bitIndex0)
      <=> v4284(VarCurr,bitIndex24) ) ) ).

fof(addAssignment_1287,axiom,
    ! [VarNext] :
      ( ( v4284(VarNext,bitIndex26)
      <=> v4589(VarNext,bitIndex2) )
      & ( v4284(VarNext,bitIndex25)
      <=> v4589(VarNext,bitIndex1) )
      & ( v4284(VarNext,bitIndex24)
      <=> v4589(VarNext,bitIndex0) ) ) ).

fof(addCaseBooleanConditionShiftedRanges1_15,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4590(VarNext)
       => ( ( v4589(VarNext,bitIndex7)
          <=> v4284(VarCurr,bitIndex31) )
          & ( v4589(VarNext,bitIndex6)
          <=> v4284(VarCurr,bitIndex30) )
          & ( v4589(VarNext,bitIndex5)
          <=> v4284(VarCurr,bitIndex29) )
          & ( v4589(VarNext,bitIndex4)
          <=> v4284(VarCurr,bitIndex28) )
          & ( v4589(VarNext,bitIndex3)
          <=> v4284(VarCurr,bitIndex27) )
          & ( v4589(VarNext,bitIndex2)
          <=> v4284(VarCurr,bitIndex26) )
          & ( v4589(VarNext,bitIndex1)
          <=> v4284(VarCurr,bitIndex25) )
          & ( v4589(VarNext,bitIndex0)
          <=> v4284(VarCurr,bitIndex24) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_88,axiom,
    ! [VarNext] :
      ( v4590(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v4589(VarNext,B)
          <=> v4616(VarNext,B) ) ) ) ).

fof(addAssignment_1286,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v4616(VarNext,B)
          <=> v4614(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_88,axiom,
    ! [VarCurr] :
      ( ~ v4507(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4614(VarCurr,B)
          <=> v4617(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_84,axiom,
    ! [VarCurr] :
      ( v4507(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4614(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_35,axiom,
    ! [VarCurr] :
      ( ( ~ v4603(VarCurr)
        & ~ v4605(VarCurr) )
     => ! [B] :
          ( range_7_0(B)
         => ( v4617(VarCurr,B)
          <=> v4582(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_87,axiom,
    ! [VarCurr] :
      ( v4605(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4617(VarCurr,B)
          <=> v4575(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0_3,axiom,
    ! [VarCurr] :
      ( v4603(VarCurr)
     => ( ( v4617(VarCurr,bitIndex7)
        <=> v4284(VarCurr,bitIndex23) )
        & ( v4617(VarCurr,bitIndex6)
        <=> v4284(VarCurr,bitIndex22) )
        & ( v4617(VarCurr,bitIndex5)
        <=> v4284(VarCurr,bitIndex21) )
        & ( v4617(VarCurr,bitIndex4)
        <=> v4284(VarCurr,bitIndex20) )
        & ( v4617(VarCurr,bitIndex3)
        <=> v4284(VarCurr,bitIndex19) )
        & ( v4617(VarCurr,bitIndex2)
        <=> v4284(VarCurr,bitIndex18) )
        & ( v4617(VarCurr,bitIndex1)
        <=> v4284(VarCurr,bitIndex17) )
        & ( v4617(VarCurr,bitIndex0)
        <=> v4284(VarCurr,bitIndex16) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_873,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4590(VarNext)
      <=> ( v4591(VarNext)
          & v4598(VarNext) ) ) ) ).

fof(addAssignment_1285,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4598(VarNext)
      <=> v4596(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_872,axiom,
    ! [VarCurr] :
      ( v4596(VarCurr)
    <=> ( v4599(VarCurr)
        & v4610(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_871,axiom,
    ! [VarCurr] :
      ( v4610(VarCurr)
    <=> ( v4611(VarCurr)
        | v4507(VarCurr) ) ) ).

fof(writeUnaryOperator_358,axiom,
    ! [VarCurr] :
      ( ~ v4611(VarCurr)
    <=> v4612(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_260,axiom,
    ! [VarCurr] :
      ( v4612(VarCurr)
    <=> ( ( v4613(VarCurr,bitIndex1)
        <=> $false )
        & ( v4613(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1284,axiom,
    ! [VarCurr] :
      ( v4613(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1283,axiom,
    ! [VarCurr] :
      ( v4613(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_870,axiom,
    ! [VarCurr] :
      ( v4599(VarCurr)
    <=> ( v4507(VarCurr)
        | v4600(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_869,axiom,
    ! [VarCurr] :
      ( v4600(VarCurr)
    <=> ( v4601(VarCurr)
        & v4609(VarCurr) ) ) ).

fof(writeUnaryOperator_357,axiom,
    ! [VarCurr] :
      ( ~ v4609(VarCurr)
    <=> v4507(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_868,axiom,
    ! [VarCurr] :
      ( v4601(VarCurr)
    <=> ( v4602(VarCurr)
        | v4607(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_259,axiom,
    ! [VarCurr] :
      ( v4607(VarCurr)
    <=> ( ( v4608(VarCurr,bitIndex1)
        <=> $true )
        & ( v4608(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1282,axiom,
    ! [VarCurr] :
      ( v4608(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1281,axiom,
    ! [VarCurr] :
      ( v4608(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_867,axiom,
    ! [VarCurr] :
      ( v4602(VarCurr)
    <=> ( v4603(VarCurr)
        | v4605(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_258,axiom,
    ! [VarCurr] :
      ( v4605(VarCurr)
    <=> ( ( v4606(VarCurr,bitIndex1)
        <=> $true )
        & ( v4606(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1280,axiom,
    ! [VarCurr] :
      ( v4606(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1279,axiom,
    ! [VarCurr] :
      ( v4606(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_257,axiom,
    ! [VarCurr] :
      ( v4603(VarCurr)
    <=> ( ( v4604(VarCurr,bitIndex1)
        <=> $false )
        & ( v4604(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1278,axiom,
    ! [VarCurr] :
      ( v4604(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1277,axiom,
    ! [VarCurr] :
      ( v4604(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_866,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4591(VarNext)
      <=> ( v4593(VarNext)
          & v2404(VarNext) ) ) ) ).

fof(writeUnaryOperator_356,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4593(VarNext)
      <=> v2411(VarNext) ) ) ).

fof(addAssignment_1276,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4582(VarCurr,B)
      <=> v4587(VarCurr,B) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_119,axiom,
    ! [VarCurr] :
      ( ~ v4584(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4587(VarCurr,B)
          <=> v4586(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_121,axiom,
    ! [VarCurr] :
      ( v4584(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4587(VarCurr,B)
          <=> v4345(VarCurr,B) ) ) ) ).

fof(addAssignment_1275,axiom,
    ! [VarCurr] :
      ( ( v4586(VarCurr,bitIndex2)
      <=> v4284(VarCurr,bitIndex18) )
      & ( v4586(VarCurr,bitIndex1)
      <=> v4284(VarCurr,bitIndex17) )
      & ( v4586(VarCurr,bitIndex0)
      <=> v4284(VarCurr,bitIndex16) ) ) ).

fof(addAssignment_1274,axiom,
    ! [VarCurr] :
      ( v4584(VarCurr)
    <=> v4290(VarCurr,bitIndex1) ) ).

fof(addAssignment_1273,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4575(VarCurr,B)
      <=> v4580(VarCurr,B) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_118,axiom,
    ! [VarCurr] :
      ( ~ v4577(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4580(VarCurr,B)
          <=> v4579(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_120,axiom,
    ! [VarCurr] :
      ( v4577(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4580(VarCurr,B)
          <=> v4345(VarCurr,B) ) ) ) ).

fof(addAssignment_1272,axiom,
    ! [VarCurr] :
      ( ( v4579(VarCurr,bitIndex2)
      <=> v4284(VarCurr,bitIndex26) )
      & ( v4579(VarCurr,bitIndex1)
      <=> v4284(VarCurr,bitIndex25) )
      & ( v4579(VarCurr,bitIndex0)
      <=> v4284(VarCurr,bitIndex24) ) ) ).

fof(addAssignment_1271,axiom,
    ! [VarCurr] :
      ( v4577(VarCurr)
    <=> v4290(VarCurr,bitIndex1) ) ).

fof(addAssignment_1270,axiom,
    ! [VarNext] :
      ( ( v4284(VarNext,bitIndex18)
      <=> v4543(VarNext,bitIndex2) )
      & ( v4284(VarNext,bitIndex17)
      <=> v4543(VarNext,bitIndex1) )
      & ( v4284(VarNext,bitIndex16)
      <=> v4543(VarNext,bitIndex0) ) ) ).

fof(addCaseBooleanConditionShiftedRanges1_14,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4544(VarNext)
       => ( ( v4543(VarNext,bitIndex7)
          <=> v4284(VarCurr,bitIndex23) )
          & ( v4543(VarNext,bitIndex6)
          <=> v4284(VarCurr,bitIndex22) )
          & ( v4543(VarNext,bitIndex5)
          <=> v4284(VarCurr,bitIndex21) )
          & ( v4543(VarNext,bitIndex4)
          <=> v4284(VarCurr,bitIndex20) )
          & ( v4543(VarNext,bitIndex3)
          <=> v4284(VarCurr,bitIndex19) )
          & ( v4543(VarNext,bitIndex2)
          <=> v4284(VarCurr,bitIndex18) )
          & ( v4543(VarNext,bitIndex1)
          <=> v4284(VarCurr,bitIndex17) )
          & ( v4543(VarNext,bitIndex0)
          <=> v4284(VarCurr,bitIndex16) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_87,axiom,
    ! [VarNext] :
      ( v4544(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v4543(VarNext,B)
          <=> v4570(VarNext,B) ) ) ) ).

fof(addAssignment_1269,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v4570(VarNext,B)
          <=> v4568(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_86,axiom,
    ! [VarCurr] :
      ( ~ v4507(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4568(VarCurr,B)
          <=> v4571(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_83,axiom,
    ! [VarCurr] :
      ( v4507(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4568(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_34,axiom,
    ! [VarCurr] :
      ( ( ~ v4557(VarCurr)
        & ~ v4559(VarCurr) )
     => ! [B] :
          ( range_7_0(B)
         => ( v4571(VarCurr,B)
          <=> v4536(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_85,axiom,
    ! [VarCurr] :
      ( v4559(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4571(VarCurr,B)
          <=> v4529(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0_2,axiom,
    ! [VarCurr] :
      ( v4557(VarCurr)
     => ( ( v4571(VarCurr,bitIndex7)
        <=> v4284(VarCurr,bitIndex15) )
        & ( v4571(VarCurr,bitIndex6)
        <=> v4284(VarCurr,bitIndex14) )
        & ( v4571(VarCurr,bitIndex5)
        <=> v4284(VarCurr,bitIndex13) )
        & ( v4571(VarCurr,bitIndex4)
        <=> v4284(VarCurr,bitIndex12) )
        & ( v4571(VarCurr,bitIndex3)
        <=> v4284(VarCurr,bitIndex11) )
        & ( v4571(VarCurr,bitIndex2)
        <=> v4284(VarCurr,bitIndex10) )
        & ( v4571(VarCurr,bitIndex1)
        <=> v4284(VarCurr,bitIndex9) )
        & ( v4571(VarCurr,bitIndex0)
        <=> v4284(VarCurr,bitIndex8) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_865,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4544(VarNext)
      <=> ( v4545(VarNext)
          & v4552(VarNext) ) ) ) ).

fof(addAssignment_1268,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4552(VarNext)
      <=> v4550(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_864,axiom,
    ! [VarCurr] :
      ( v4550(VarCurr)
    <=> ( v4553(VarCurr)
        & v4564(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_863,axiom,
    ! [VarCurr] :
      ( v4564(VarCurr)
    <=> ( v4565(VarCurr)
        | v4507(VarCurr) ) ) ).

fof(writeUnaryOperator_355,axiom,
    ! [VarCurr] :
      ( ~ v4565(VarCurr)
    <=> v4566(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_256,axiom,
    ! [VarCurr] :
      ( v4566(VarCurr)
    <=> ( ( v4567(VarCurr,bitIndex1)
        <=> $false )
        & ( v4567(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1267,axiom,
    ! [VarCurr] :
      ( v4567(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1266,axiom,
    ! [VarCurr] :
      ( v4567(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_862,axiom,
    ! [VarCurr] :
      ( v4553(VarCurr)
    <=> ( v4507(VarCurr)
        | v4554(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_861,axiom,
    ! [VarCurr] :
      ( v4554(VarCurr)
    <=> ( v4555(VarCurr)
        & v4563(VarCurr) ) ) ).

fof(writeUnaryOperator_354,axiom,
    ! [VarCurr] :
      ( ~ v4563(VarCurr)
    <=> v4507(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_860,axiom,
    ! [VarCurr] :
      ( v4555(VarCurr)
    <=> ( v4556(VarCurr)
        | v4561(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_255,axiom,
    ! [VarCurr] :
      ( v4561(VarCurr)
    <=> ( ( v4562(VarCurr,bitIndex1)
        <=> $true )
        & ( v4562(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1265,axiom,
    ! [VarCurr] :
      ( v4562(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1264,axiom,
    ! [VarCurr] :
      ( v4562(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_859,axiom,
    ! [VarCurr] :
      ( v4556(VarCurr)
    <=> ( v4557(VarCurr)
        | v4559(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_254,axiom,
    ! [VarCurr] :
      ( v4559(VarCurr)
    <=> ( ( v4560(VarCurr,bitIndex1)
        <=> $true )
        & ( v4560(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1263,axiom,
    ! [VarCurr] :
      ( v4560(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1262,axiom,
    ! [VarCurr] :
      ( v4560(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_253,axiom,
    ! [VarCurr] :
      ( v4557(VarCurr)
    <=> ( ( v4558(VarCurr,bitIndex1)
        <=> $false )
        & ( v4558(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1261,axiom,
    ! [VarCurr] :
      ( v4558(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1260,axiom,
    ! [VarCurr] :
      ( v4558(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_858,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4545(VarNext)
      <=> ( v4547(VarNext)
          & v2404(VarNext) ) ) ) ).

fof(writeUnaryOperator_353,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4547(VarNext)
      <=> v2411(VarNext) ) ) ).

fof(addAssignment_1259,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4536(VarCurr,B)
      <=> v4541(VarCurr,B) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_117,axiom,
    ! [VarCurr] :
      ( ~ v4538(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4541(VarCurr,B)
          <=> v4540(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_119,axiom,
    ! [VarCurr] :
      ( v4538(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4541(VarCurr,B)
          <=> v4345(VarCurr,B) ) ) ) ).

fof(addAssignment_1258,axiom,
    ! [VarCurr] :
      ( ( v4540(VarCurr,bitIndex2)
      <=> v4284(VarCurr,bitIndex10) )
      & ( v4540(VarCurr,bitIndex1)
      <=> v4284(VarCurr,bitIndex9) )
      & ( v4540(VarCurr,bitIndex0)
      <=> v4284(VarCurr,bitIndex8) ) ) ).

fof(addAssignment_1257,axiom,
    ! [VarCurr] :
      ( v4538(VarCurr)
    <=> v4290(VarCurr,bitIndex2) ) ).

fof(addAssignment_1256,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4529(VarCurr,B)
      <=> v4534(VarCurr,B) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_116,axiom,
    ! [VarCurr] :
      ( ~ v4531(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4534(VarCurr,B)
          <=> v4533(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_118,axiom,
    ! [VarCurr] :
      ( v4531(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4534(VarCurr,B)
          <=> v4345(VarCurr,B) ) ) ) ).

fof(addAssignment_1255,axiom,
    ! [VarCurr] :
      ( ( v4533(VarCurr,bitIndex2)
      <=> v4284(VarCurr,bitIndex18) )
      & ( v4533(VarCurr,bitIndex1)
      <=> v4284(VarCurr,bitIndex17) )
      & ( v4533(VarCurr,bitIndex0)
      <=> v4284(VarCurr,bitIndex16) ) ) ).

fof(addAssignment_1254,axiom,
    ! [VarCurr] :
      ( v4531(VarCurr)
    <=> v4290(VarCurr,bitIndex2) ) ).

fof(addAssignment_1253,axiom,
    ! [VarNext] :
      ( ( v4284(VarNext,bitIndex10)
      <=> v4496(VarNext,bitIndex2) )
      & ( v4284(VarNext,bitIndex9)
      <=> v4496(VarNext,bitIndex1) )
      & ( v4284(VarNext,bitIndex8)
      <=> v4496(VarNext,bitIndex0) ) ) ).

fof(addCaseBooleanConditionShiftedRanges1_13,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4497(VarNext)
       => ( ( v4496(VarNext,bitIndex7)
          <=> v4284(VarCurr,bitIndex15) )
          & ( v4496(VarNext,bitIndex6)
          <=> v4284(VarCurr,bitIndex14) )
          & ( v4496(VarNext,bitIndex5)
          <=> v4284(VarCurr,bitIndex13) )
          & ( v4496(VarNext,bitIndex4)
          <=> v4284(VarCurr,bitIndex12) )
          & ( v4496(VarNext,bitIndex3)
          <=> v4284(VarCurr,bitIndex11) )
          & ( v4496(VarNext,bitIndex2)
          <=> v4284(VarCurr,bitIndex10) )
          & ( v4496(VarNext,bitIndex1)
          <=> v4284(VarCurr,bitIndex9) )
          & ( v4496(VarNext,bitIndex0)
          <=> v4284(VarCurr,bitIndex8) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_86,axiom,
    ! [VarNext] :
      ( v4497(VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v4496(VarNext,B)
          <=> v4524(VarNext,B) ) ) ) ).

fof(addAssignment_1252,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_7_0(B)
         => ( v4524(VarNext,B)
          <=> v4522(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_84,axiom,
    ! [VarCurr] :
      ( ~ v4507(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4522(VarCurr,B)
          <=> v4525(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_82,axiom,
    ! [VarCurr] :
      ( v4507(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4522(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_33,axiom,
    ! [VarCurr] :
      ( ( ~ v4511(VarCurr)
        & ~ v4513(VarCurr) )
     => ! [B] :
          ( range_7_0(B)
         => ( v4525(VarCurr,B)
          <=> v4489(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_83,axiom,
    ! [VarCurr] :
      ( v4513(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4525(VarCurr,B)
          <=> v4286(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_81,axiom,
    ! [VarCurr] :
      ( v4511(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4525(VarCurr,B)
          <=> v4284(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_857,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4497(VarNext)
      <=> ( v4498(VarNext)
          & v4505(VarNext) ) ) ) ).

fof(addAssignment_1251,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4505(VarNext)
      <=> v4503(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_856,axiom,
    ! [VarCurr] :
      ( v4503(VarCurr)
    <=> ( v4506(VarCurr)
        & v4518(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_855,axiom,
    ! [VarCurr] :
      ( v4518(VarCurr)
    <=> ( v4519(VarCurr)
        | v4507(VarCurr) ) ) ).

fof(writeUnaryOperator_352,axiom,
    ! [VarCurr] :
      ( ~ v4519(VarCurr)
    <=> v4520(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_252,axiom,
    ! [VarCurr] :
      ( v4520(VarCurr)
    <=> ( ( v4521(VarCurr,bitIndex1)
        <=> $false )
        & ( v4521(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1250,axiom,
    ! [VarCurr] :
      ( v4521(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1249,axiom,
    ! [VarCurr] :
      ( v4521(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_854,axiom,
    ! [VarCurr] :
      ( v4506(VarCurr)
    <=> ( v4507(VarCurr)
        | v4508(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_853,axiom,
    ! [VarCurr] :
      ( v4508(VarCurr)
    <=> ( v4509(VarCurr)
        & v4517(VarCurr) ) ) ).

fof(writeUnaryOperator_351,axiom,
    ! [VarCurr] :
      ( ~ v4517(VarCurr)
    <=> v4507(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_852,axiom,
    ! [VarCurr] :
      ( v4509(VarCurr)
    <=> ( v4510(VarCurr)
        | v4515(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_251,axiom,
    ! [VarCurr] :
      ( v4515(VarCurr)
    <=> ( ( v4516(VarCurr,bitIndex1)
        <=> $true )
        & ( v4516(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1248,axiom,
    ! [VarCurr] :
      ( v4516(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1247,axiom,
    ! [VarCurr] :
      ( v4516(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_851,axiom,
    ! [VarCurr] :
      ( v4510(VarCurr)
    <=> ( v4511(VarCurr)
        | v4513(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_250,axiom,
    ! [VarCurr] :
      ( v4513(VarCurr)
    <=> ( ( v4514(VarCurr,bitIndex1)
        <=> $true )
        & ( v4514(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1246,axiom,
    ! [VarCurr] :
      ( v4514(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1245,axiom,
    ! [VarCurr] :
      ( v4514(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_249,axiom,
    ! [VarCurr] :
      ( v4511(VarCurr)
    <=> ( ( v4512(VarCurr,bitIndex1)
        <=> $false )
        & ( v4512(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1244,axiom,
    ! [VarCurr] :
      ( v4512(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1243,axiom,
    ! [VarCurr] :
      ( v4512(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(writeUnaryOperator_350,axiom,
    ! [VarCurr] :
      ( ~ v4507(VarCurr)
    <=> v2374(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_850,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4498(VarNext)
      <=> ( v4499(VarNext)
          & v2404(VarNext) ) ) ) ).

fof(writeUnaryOperator_349,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4499(VarNext)
      <=> v2411(VarNext) ) ) ).

fof(addAssignment_1242,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4489(VarCurr,B)
      <=> v4494(VarCurr,B) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_115,axiom,
    ! [VarCurr] :
      ( ~ v4491(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4494(VarCurr,B)
          <=> v4493(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_117,axiom,
    ! [VarCurr] :
      ( v4491(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4494(VarCurr,B)
          <=> v4345(VarCurr,B) ) ) ) ).

fof(addAssignment_1241,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4493(VarCurr,B)
      <=> v4284(VarCurr,B) ) ) ).

fof(addAssignment_1240,axiom,
    ! [VarCurr] :
      ( v4491(VarCurr)
    <=> v4290(VarCurr,bitIndex3) ) ).

fof(addAssignment_1239,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4286(VarCurr,B)
      <=> v4487(VarCurr,B) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_114,axiom,
    ! [VarCurr] :
      ( ~ v4288(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4487(VarCurr,B)
          <=> v4482(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_116,axiom,
    ! [VarCurr] :
      ( v4288(VarCurr)
     => ! [B] :
          ( range_7_0(B)
         => ( v4487(VarCurr,B)
          <=> v4345(VarCurr,B) ) ) ) ).

fof(addAssignment_1238,axiom,
    ! [VarCurr] :
      ( ( v4482(VarCurr,bitIndex2)
      <=> v4284(VarCurr,bitIndex10) )
      & ( v4482(VarCurr,bitIndex1)
      <=> v4284(VarCurr,bitIndex9) )
      & ( v4482(VarCurr,bitIndex0)
      <=> v4284(VarCurr,bitIndex8) ) ) ).

fof(addAssignmentInitValue_28,axiom,
    ~ v4284(constB0,bitIndex28) ).

fof(addAssignmentInitValue_27,axiom,
    ~ v4284(constB0,bitIndex26) ).

fof(addAssignmentInitValue_26,axiom,
    ~ v4284(constB0,bitIndex25) ).

fof(addAssignmentInitValue_25,axiom,
    ~ v4284(constB0,bitIndex24) ).

fof(bitBlastConstant_385,axiom,
    ~ bxxx0x000(bitIndex4) ).

fof(bitBlastConstant_384,axiom,
    ~ bxxx0x000(bitIndex2) ).

fof(bitBlastConstant_383,axiom,
    ~ bxxx0x000(bitIndex1) ).

fof(bitBlastConstant_382,axiom,
    ~ bxxx0x000(bitIndex0) ).

fof(addAssignmentInitValue_24,axiom,
    ~ v4284(constB0,bitIndex18) ).

fof(addAssignmentInitValue_23,axiom,
    ~ v4284(constB0,bitIndex17) ).

fof(addAssignmentInitValue_22,axiom,
    ~ v4284(constB0,bitIndex16) ).

fof(bitBlastConstant_381,axiom,
    ~ bxxxxx000(bitIndex2) ).

fof(bitBlastConstant_380,axiom,
    ~ bxxxxx000(bitIndex1) ).

fof(bitBlastConstant_379,axiom,
    ~ bxxxxx000(bitIndex0) ).

fof(addAssignment_1237,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4345(VarCurr,B)
      <=> v4347(VarCurr,B) ) ) ).

fof(addAssignment_1236,axiom,
    ! [VarCurr] :
      ( ( v4347(VarCurr,bitIndex2)
      <=> v3269(VarCurr,bitIndex57) )
      & ( v4347(VarCurr,bitIndex1)
      <=> v3269(VarCurr,bitIndex56) )
      & ( v4347(VarCurr,bitIndex0)
      <=> v3269(VarCurr,bitIndex55) ) ) ).

fof(addAssignment_1235,axiom,
    ! [VarCurr,B] :
      ( range_57_55(B)
     => ( v3269(VarCurr,B)
      <=> v3271(VarCurr,B) ) ) ).

fof(addAssignment_1234,axiom,
    ! [VarCurr,B] :
      ( range_57_55(B)
     => ( v3271(VarCurr,B)
      <=> v3273(VarCurr,B) ) ) ).

fof(addAssignment_1233,axiom,
    ! [VarCurr,B] :
      ( range_57_55(B)
     => ( v3273(VarCurr,B)
      <=> v3275(VarCurr,B) ) ) ).

fof(addAssignment_1232,axiom,
    ! [VarCurr,B] :
      ( range_57_55(B)
     => ( v3275(VarCurr,B)
      <=> v3277(VarCurr,B) ) ) ).

fof(addAssignment_1231,axiom,
    ! [VarCurr,B] :
      ( range_57_55(B)
     => ( v3277(VarCurr,B)
      <=> v3279(VarCurr,B) ) ) ).

fof(addAssignment_1230,axiom,
    ! [VarCurr,B] :
      ( range_57_55(B)
     => ( v3279(VarCurr,B)
      <=> v3281(VarCurr,B) ) ) ).

fof(addAssignment_1229,axiom,
    ! [VarCurr,B] :
      ( range_57_55(B)
     => ( v3281(VarCurr,B)
      <=> v4121(VarCurr,B) ) ) ).

fof(range_axiom_33,axiom,
    ! [B] :
      ( range_57_55(B)
    <=> ( $false
        | bitIndex55 = B
        | bitIndex56 = B
        | bitIndex57 = B ) ) ).

fof(addAssignment_1228,axiom,
    ! [VarNext,B] :
      ( range_2_0(B)
     => ( v4126(VarNext,B)
      <=> v4464(VarNext,B) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_75,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4465(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v4464(VarNext,B)
            <=> v4126(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_85,axiom,
    ! [VarNext] :
      ( v4465(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v4464(VarNext,B)
          <=> v4478(VarNext,B) ) ) ) ).

fof(addAssignment_1227,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v4478(VarNext,B)
          <=> v4476(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_82,axiom,
    ! [VarCurr] :
      ( ~ v4113(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v4476(VarCurr,B)
          <=> v4349(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_80,axiom,
    ! [VarCurr] :
      ( v4113(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v4476(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_849,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4465(VarNext)
      <=> ( v4466(VarNext)
          & v4473(VarNext) ) ) ) ).

fof(addAssignment_1226,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4473(VarNext)
      <=> v4471(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_848,axiom,
    ! [VarCurr] :
      ( v4471(VarCurr)
    <=> ( v4113(VarCurr)
        | v4474(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_847,axiom,
    ! [VarCurr] :
      ( v4474(VarCurr)
    <=> ( v3287(VarCurr)
        & v4475(VarCurr) ) ) ).

fof(writeUnaryOperator_348,axiom,
    ! [VarCurr] :
      ( ~ v4475(VarCurr)
    <=> v4113(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_846,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4466(VarNext)
      <=> ( v4468(VarNext)
          & v4099(VarNext) ) ) ) ).

fof(writeUnaryOperator_347,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4468(VarNext)
      <=> v4106(VarNext) ) ) ).

fof(addAssignment_1225,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4349(VarCurr,B)
      <=> v4462(VarCurr,B) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_32,axiom,
    ! [VarCurr] :
      ( ( ~ v4093(VarCurr)
        & ~ v4094(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v4462(VarCurr,B)
          <=> v4459(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_81,axiom,
    ! [VarCurr] :
      ( v4094(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v4462(VarCurr,B)
          <=> v4366(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_79,axiom,
    ! [VarCurr] :
      ( v4093(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v4462(VarCurr,B)
          <=> v4351(VarCurr,B) ) ) ) ).

fof(addAssignment_1224,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4459(VarCurr,B)
      <=> v4460(VarCurr,B) ) ) ).

fof(addAssignment_1223,axiom,
    ! [VarCurr] :
      ( v4460(VarCurr,bitIndex0)
    <=> v4461(VarCurr) ) ).

fof(addAssignment_1222,axiom,
    ! [VarCurr] :
      ( v4460(VarCurr,bitIndex1)
    <=> $false ) ).

fof(addAssignment_1221,axiom,
    ! [VarCurr] :
      ( v4460(VarCurr,bitIndex2)
    <=> v4003(VarCurr,bitIndex0) ) ).

fof(addAssignment_1220,axiom,
    ! [VarCurr] :
      ( v4460(VarCurr,bitIndex3)
    <=> $false ) ).

fof(writeBinaryOperatorShiftedRanges_130,axiom,
    ! [VarCurr] :
      ( v4461(VarCurr)
    <=> ( v4003(VarCurr,bitIndex2)
        | v4003(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1219,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4366(VarCurr,B)
      <=> v4402(VarCurr,B) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_113,axiom,
    ! [VarCurr] :
      ( ~ v4403(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v4402(VarCurr,B)
          <=> $false ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_115,axiom,
    ! [VarCurr] :
      ( v4403(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v4402(VarCurr,B)
          <=> v4451(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges8,axiom,
    ! [VarCurr] :
      ( ( ~ v4411(VarCurr)
        & ~ v4413(VarCurr)
        & ~ v4422(VarCurr)
        & ~ v4425(VarCurr)
        & ~ v4429(VarCurr)
        & ~ v4434(VarCurr)
        & ~ v4439(VarCurr)
        & ~ v4442(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v4451(VarCurr,B)
          <=> $true ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges7_1,axiom,
    ! [VarCurr] :
      ( v4442(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v4451(VarCurr,B)
          <=> v4457(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges6_1,axiom,
    ! [VarCurr] :
      ( v4439(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v4451(VarCurr,B)
          <=> v4456(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges5_1,axiom,
    ! [VarCurr] :
      ( v4434(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v4451(VarCurr,B)
          <=> v4455(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges4_1,axiom,
    ! [VarCurr] :
      ( v4429(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v4451(VarCurr,B)
          <=> v4454(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_16,axiom,
    ! [VarCurr] :
      ( v4425(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v4451(VarCurr,B)
          <=> v4453(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_31,axiom,
    ! [VarCurr] :
      ( v4422(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v4451(VarCurr,B)
          <=> v4452(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_80,axiom,
    ! [VarCurr] :
      ( v4413(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v4451(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_78,axiom,
    ! [VarCurr] :
      ( v4411(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v4451(VarCurr,B)
          <=> $true ) ) ) ).

fof(addAssignment_1218,axiom,
    ! [VarCurr] :
      ( v4457(VarCurr,bitIndex0)
    <=> v4370(VarCurr,bitIndex15) ) ).

fof(addAssignment_1217,axiom,
    ! [VarCurr] :
      ( v4457(VarCurr,bitIndex1)
    <=> v4370(VarCurr,bitIndex14) ) ).

fof(addAssignment_1216,axiom,
    ! [VarCurr] :
      ( v4457(VarCurr,bitIndex2)
    <=> v4370(VarCurr,bitIndex13) ) ).

fof(addAssignment_1215,axiom,
    ! [VarCurr] :
      ( v4457(VarCurr,bitIndex3)
    <=> v4370(VarCurr,bitIndex12) ) ).

fof(addAssignment_1214,axiom,
    ! [VarCurr] :
      ( v4456(VarCurr,bitIndex0)
    <=> v4370(VarCurr,bitIndex7) ) ).

fof(addAssignment_1213,axiom,
    ! [VarCurr] :
      ( v4456(VarCurr,bitIndex1)
    <=> v4370(VarCurr,bitIndex6) ) ).

fof(addAssignment_1212,axiom,
    ! [VarCurr] :
      ( v4456(VarCurr,bitIndex2)
    <=> v4370(VarCurr,bitIndex5) ) ).

fof(addAssignment_1211,axiom,
    ! [VarCurr] :
      ( v4456(VarCurr,bitIndex3)
    <=> v4370(VarCurr,bitIndex4) ) ).

fof(addAssignment_1210,axiom,
    ! [VarCurr] :
      ( v4455(VarCurr,bitIndex0)
    <=> v4370(VarCurr,bitIndex15) ) ).

fof(addAssignment_1209,axiom,
    ! [VarCurr] :
      ( v4455(VarCurr,bitIndex1)
    <=> v4370(VarCurr,bitIndex14) ) ).

fof(addAssignment_1208,axiom,
    ! [VarCurr] :
      ( v4455(VarCurr,bitIndex2)
    <=> v4370(VarCurr,bitIndex13) ) ).

fof(addAssignment_1207,axiom,
    ! [VarCurr] :
      ( v4455(VarCurr,bitIndex3)
    <=> v4370(VarCurr,bitIndex12) ) ).

fof(addAssignment_1206,axiom,
    ! [VarCurr] :
      ( v4454(VarCurr,bitIndex0)
    <=> v4370(VarCurr,bitIndex11) ) ).

fof(addAssignment_1205,axiom,
    ! [VarCurr] :
      ( v4454(VarCurr,bitIndex1)
    <=> v4370(VarCurr,bitIndex10) ) ).

fof(addAssignment_1204,axiom,
    ! [VarCurr] :
      ( v4454(VarCurr,bitIndex2)
    <=> v4370(VarCurr,bitIndex9) ) ).

fof(addAssignment_1203,axiom,
    ! [VarCurr] :
      ( v4454(VarCurr,bitIndex3)
    <=> v4370(VarCurr,bitIndex8) ) ).

fof(addAssignment_1202,axiom,
    ! [VarCurr] :
      ( v4453(VarCurr,bitIndex0)
    <=> v4370(VarCurr,bitIndex7) ) ).

fof(addAssignment_1201,axiom,
    ! [VarCurr] :
      ( v4453(VarCurr,bitIndex1)
    <=> v4370(VarCurr,bitIndex6) ) ).

fof(addAssignment_1200,axiom,
    ! [VarCurr] :
      ( v4453(VarCurr,bitIndex2)
    <=> v4370(VarCurr,bitIndex5) ) ).

fof(addAssignment_1199,axiom,
    ! [VarCurr] :
      ( v4453(VarCurr,bitIndex3)
    <=> v4370(VarCurr,bitIndex4) ) ).

fof(addAssignment_1198,axiom,
    ! [VarCurr] :
      ( v4452(VarCurr,bitIndex0)
    <=> v4370(VarCurr,bitIndex3) ) ).

fof(addAssignment_1197,axiom,
    ! [VarCurr] :
      ( v4452(VarCurr,bitIndex1)
    <=> v4370(VarCurr,bitIndex2) ) ).

fof(addAssignment_1196,axiom,
    ! [VarCurr] :
      ( v4452(VarCurr,bitIndex2)
    <=> v4370(VarCurr,bitIndex1) ) ).

fof(addAssignment_1195,axiom,
    ! [VarCurr] :
      ( v4452(VarCurr,bitIndex3)
    <=> v4370(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_845,axiom,
    ! [VarCurr] :
      ( v4403(VarCurr)
    <=> ( v4404(VarCurr)
        | v4447(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_129,axiom,
    ! [VarCurr] :
      ( v4447(VarCurr)
    <=> ( v4449(VarCurr)
        & v522(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_844,axiom,
    ! [VarCurr] :
      ( v4449(VarCurr)
    <=> ( v4450(VarCurr)
        & v4390(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_843,axiom,
    ! [VarCurr] :
      ( v4450(VarCurr)
    <=> ( v4446(VarCurr)
        & v4384(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_842,axiom,
    ! [VarCurr] :
      ( v4404(VarCurr)
    <=> ( v4405(VarCurr)
        | v4442(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_128,axiom,
    ! [VarCurr] :
      ( v4442(VarCurr)
    <=> ( v4444(VarCurr)
        & v522(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_841,axiom,
    ! [VarCurr] :
      ( v4444(VarCurr)
    <=> ( v4445(VarCurr)
        & v4421(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_840,axiom,
    ! [VarCurr] :
      ( v4445(VarCurr)
    <=> ( v4446(VarCurr)
        & v4420(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_839,axiom,
    ! [VarCurr] :
      ( v4446(VarCurr)
    <=> ( v4368(VarCurr)
        & v4378(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_838,axiom,
    ! [VarCurr] :
      ( v4405(VarCurr)
    <=> ( v4406(VarCurr)
        | v4439(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_127,axiom,
    ! [VarCurr] :
      ( v4439(VarCurr)
    <=> ( v4441(VarCurr)
        & v522(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_837,axiom,
    ! [VarCurr] :
      ( v4441(VarCurr)
    <=> ( v4428(VarCurr)
        & v4390(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_836,axiom,
    ! [VarCurr] :
      ( v4406(VarCurr)
    <=> ( v4407(VarCurr)
        | v4434(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_126,axiom,
    ! [VarCurr] :
      ( v4434(VarCurr)
    <=> ( v4436(VarCurr)
        & v522(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_835,axiom,
    ! [VarCurr] :
      ( v4436(VarCurr)
    <=> ( v4437(VarCurr)
        & v4421(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_834,axiom,
    ! [VarCurr] :
      ( v4437(VarCurr)
    <=> ( v4438(VarCurr)
        & v4420(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_833,axiom,
    ! [VarCurr] :
      ( v4438(VarCurr)
    <=> ( v4368(VarCurr)
        & v4419(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_832,axiom,
    ! [VarCurr] :
      ( v4407(VarCurr)
    <=> ( v4408(VarCurr)
        | v4429(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_125,axiom,
    ! [VarCurr] :
      ( v4429(VarCurr)
    <=> ( v4431(VarCurr)
        & v522(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_831,axiom,
    ! [VarCurr] :
      ( v4431(VarCurr)
    <=> ( v4432(VarCurr)
        & v4421(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_830,axiom,
    ! [VarCurr] :
      ( v4432(VarCurr)
    <=> ( v4433(VarCurr)
        & v4420(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_829,axiom,
    ! [VarCurr] :
      ( v4433(VarCurr)
    <=> ( v4418(VarCurr)
        & v4378(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_828,axiom,
    ! [VarCurr] :
      ( v4408(VarCurr)
    <=> ( v4409(VarCurr)
        | v4425(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_124,axiom,
    ! [VarCurr] :
      ( v4425(VarCurr)
    <=> ( v4427(VarCurr)
        & v522(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_827,axiom,
    ! [VarCurr] :
      ( v4427(VarCurr)
    <=> ( v4428(VarCurr)
        & v4421(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_826,axiom,
    ! [VarCurr] :
      ( v4428(VarCurr)
    <=> ( v4417(VarCurr)
        & v4384(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_825,axiom,
    ! [VarCurr] :
      ( v4409(VarCurr)
    <=> ( v4410(VarCurr)
        | v4422(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_123,axiom,
    ! [VarCurr] :
      ( v4422(VarCurr)
    <=> ( v4424(VarCurr)
        & v522(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_824,axiom,
    ! [VarCurr] :
      ( v4424(VarCurr)
    <=> ( v4416(VarCurr)
        & v4390(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_823,axiom,
    ! [VarCurr] :
      ( v4410(VarCurr)
    <=> ( v4411(VarCurr)
        | v4413(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_122,axiom,
    ! [VarCurr] :
      ( v4413(VarCurr)
    <=> ( v4415(VarCurr)
        & v522(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_822,axiom,
    ! [VarCurr] :
      ( v4415(VarCurr)
    <=> ( v4416(VarCurr)
        & v4421(VarCurr) ) ) ).

fof(writeUnaryOperator_346,axiom,
    ! [VarCurr] :
      ( ~ v4421(VarCurr)
    <=> v4390(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_821,axiom,
    ! [VarCurr] :
      ( v4416(VarCurr)
    <=> ( v4417(VarCurr)
        & v4420(VarCurr) ) ) ).

fof(writeUnaryOperator_345,axiom,
    ! [VarCurr] :
      ( ~ v4420(VarCurr)
    <=> v4384(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_820,axiom,
    ! [VarCurr] :
      ( v4417(VarCurr)
    <=> ( v4418(VarCurr)
        & v4419(VarCurr) ) ) ).

fof(writeUnaryOperator_344,axiom,
    ! [VarCurr] :
      ( ~ v4419(VarCurr)
    <=> v4378(VarCurr) ) ).

fof(writeUnaryOperator_343,axiom,
    ! [VarCurr] :
      ( ~ v4418(VarCurr)
    <=> v4368(VarCurr) ) ).

fof(writeUnaryOperator_342,axiom,
    ! [VarCurr] :
      ( ~ v4411(VarCurr)
    <=> v522(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges_121,axiom,
    ! [VarCurr] :
      ( v4390(VarCurr)
    <=> ( v4393(VarCurr)
        | v4370(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_120,axiom,
    ! [VarCurr] :
      ( v4393(VarCurr)
    <=> ( v4394(VarCurr)
        | v4370(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_119,axiom,
    ! [VarCurr] :
      ( v4394(VarCurr)
    <=> ( v4370(VarCurr,bitIndex0)
        | v4370(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1194,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v4370(VarCurr,B)
      <=> v4372(VarCurr,B) ) ) ).

fof(addAssignment_1193,axiom,
    ! [VarCurr] :
      ( ( v4372(VarCurr,bitIndex3)
      <=> v526(VarCurr,bitIndex14) )
      & ( v4372(VarCurr,bitIndex2)
      <=> v526(VarCurr,bitIndex13) )
      & ( v4372(VarCurr,bitIndex1)
      <=> v526(VarCurr,bitIndex12) )
      & ( v4372(VarCurr,bitIndex0)
      <=> v526(VarCurr,bitIndex11) ) ) ).

fof(addAssignment_1192,axiom,
    ! [VarCurr,B] :
      ( range_14_11(B)
     => ( v526(VarCurr,B)
      <=> v528(VarCurr,B) ) ) ).

fof(addAssignment_1191,axiom,
    ! [VarCurr,B] :
      ( range_14_11(B)
     => ( v528(VarCurr,B)
      <=> v598(VarCurr,B) ) ) ).

fof(range_axiom_32,axiom,
    ! [B] :
      ( range_14_11(B)
    <=> ( $false
        | bitIndex11 = B
        | bitIndex12 = B
        | bitIndex13 = B
        | bitIndex14 = B ) ) ).

fof(writeBinaryOperatorShiftedRanges_118,axiom,
    ! [VarCurr] :
      ( v4384(VarCurr)
    <=> ( v4387(VarCurr)
        | v4370(VarCurr,bitIndex7) ) ) ).

fof(writeBinaryOperatorShiftedRanges_117,axiom,
    ! [VarCurr] :
      ( v4387(VarCurr)
    <=> ( v4388(VarCurr)
        | v4370(VarCurr,bitIndex6) ) ) ).

fof(writeBinaryOperatorShiftedRanges_116,axiom,
    ! [VarCurr] :
      ( v4388(VarCurr)
    <=> ( v4370(VarCurr,bitIndex4)
        | v4370(VarCurr,bitIndex5) ) ) ).

fof(addAssignment_1190,axiom,
    ! [VarCurr,B] :
      ( range_7_4(B)
     => ( v4370(VarCurr,B)
      <=> v4372(VarCurr,B) ) ) ).

fof(range_axiom_31,axiom,
    ! [B] :
      ( range_7_4(B)
    <=> ( $false
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B ) ) ).

fof(addAssignment_1189,axiom,
    ! [VarCurr] :
      ( ( v4372(VarCurr,bitIndex7)
      <=> v526(VarCurr,bitIndex18) )
      & ( v4372(VarCurr,bitIndex6)
      <=> v526(VarCurr,bitIndex17) )
      & ( v4372(VarCurr,bitIndex5)
      <=> v526(VarCurr,bitIndex16) )
      & ( v4372(VarCurr,bitIndex4)
      <=> v526(VarCurr,bitIndex15) ) ) ).

fof(addAssignment_1188,axiom,
    ! [VarCurr,B] :
      ( range_18_15(B)
     => ( v526(VarCurr,B)
      <=> v528(VarCurr,B) ) ) ).

fof(addAssignment_1187,axiom,
    ! [VarCurr,B] :
      ( range_18_15(B)
     => ( v528(VarCurr,B)
      <=> v598(VarCurr,B) ) ) ).

fof(range_axiom_30,axiom,
    ! [B] :
      ( range_18_15(B)
    <=> ( $false
        | bitIndex15 = B
        | bitIndex16 = B
        | bitIndex17 = B
        | bitIndex18 = B ) ) ).

fof(writeBinaryOperatorShiftedRanges_115,axiom,
    ! [VarCurr] :
      ( v4378(VarCurr)
    <=> ( v4381(VarCurr)
        | v4370(VarCurr,bitIndex11) ) ) ).

fof(writeBinaryOperatorShiftedRanges_114,axiom,
    ! [VarCurr] :
      ( v4381(VarCurr)
    <=> ( v4382(VarCurr)
        | v4370(VarCurr,bitIndex10) ) ) ).

fof(writeBinaryOperatorShiftedRanges_113,axiom,
    ! [VarCurr] :
      ( v4382(VarCurr)
    <=> ( v4370(VarCurr,bitIndex8)
        | v4370(VarCurr,bitIndex9) ) ) ).

fof(addAssignment_1186,axiom,
    ! [VarCurr,B] :
      ( range_11_8(B)
     => ( v4370(VarCurr,B)
      <=> v4372(VarCurr,B) ) ) ).

fof(range_axiom_29,axiom,
    ! [B] :
      ( range_11_8(B)
    <=> ( $false
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B
        | bitIndex11 = B ) ) ).

fof(addAssignment_1185,axiom,
    ! [VarCurr] :
      ( ( v4372(VarCurr,bitIndex11)
      <=> v526(VarCurr,bitIndex22) )
      & ( v4372(VarCurr,bitIndex10)
      <=> v526(VarCurr,bitIndex21) )
      & ( v4372(VarCurr,bitIndex9)
      <=> v526(VarCurr,bitIndex20) )
      & ( v4372(VarCurr,bitIndex8)
      <=> v526(VarCurr,bitIndex19) ) ) ).

fof(addAssignment_1184,axiom,
    ! [VarCurr,B] :
      ( range_22_19(B)
     => ( v526(VarCurr,B)
      <=> v528(VarCurr,B) ) ) ).

fof(addAssignment_1183,axiom,
    ! [VarCurr,B] :
      ( range_22_19(B)
     => ( v528(VarCurr,B)
      <=> v598(VarCurr,B) ) ) ).

fof(range_axiom_28,axiom,
    ! [B] :
      ( range_22_19(B)
    <=> ( $false
        | bitIndex19 = B
        | bitIndex20 = B
        | bitIndex21 = B
        | bitIndex22 = B ) ) ).

fof(writeBinaryOperatorShiftedRanges_112,axiom,
    ! [VarCurr] :
      ( v4368(VarCurr)
    <=> ( v4375(VarCurr)
        | v4370(VarCurr,bitIndex15) ) ) ).

fof(writeBinaryOperatorShiftedRanges_111,axiom,
    ! [VarCurr] :
      ( v4375(VarCurr)
    <=> ( v4376(VarCurr)
        | v4370(VarCurr,bitIndex14) ) ) ).

fof(writeBinaryOperatorShiftedRanges_110,axiom,
    ! [VarCurr] :
      ( v4376(VarCurr)
    <=> ( v4370(VarCurr,bitIndex12)
        | v4370(VarCurr,bitIndex13) ) ) ).

fof(addAssignment_1182,axiom,
    ! [VarCurr,B] :
      ( range_15_12(B)
     => ( v4370(VarCurr,B)
      <=> v4372(VarCurr,B) ) ) ).

fof(range_axiom_27,axiom,
    ! [B] :
      ( range_15_12(B)
    <=> ( $false
        | bitIndex12 = B
        | bitIndex13 = B
        | bitIndex14 = B
        | bitIndex15 = B ) ) ).

fof(addAssignment_1181,axiom,
    ! [VarCurr] :
      ( ( v4372(VarCurr,bitIndex15)
      <=> v526(VarCurr,bitIndex26) )
      & ( v4372(VarCurr,bitIndex14)
      <=> v526(VarCurr,bitIndex25) )
      & ( v4372(VarCurr,bitIndex13)
      <=> v526(VarCurr,bitIndex24) )
      & ( v4372(VarCurr,bitIndex12)
      <=> v526(VarCurr,bitIndex23) ) ) ).

fof(addAssignment_1180,axiom,
    ! [VarCurr,B] :
      ( range_26_23(B)
     => ( v526(VarCurr,B)
      <=> v528(VarCurr,B) ) ) ).

fof(addAssignment_1179,axiom,
    ! [VarCurr,B] :
      ( range_26_23(B)
     => ( v528(VarCurr,B)
      <=> v598(VarCurr,B) ) ) ).

fof(range_axiom_26,axiom,
    ! [B] :
      ( range_26_23(B)
    <=> ( $false
        | bitIndex23 = B
        | bitIndex24 = B
        | bitIndex25 = B
        | bitIndex26 = B ) ) ).

fof(addAssignment_1178,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4351(VarCurr,B)
      <=> v4364(VarCurr,B) ) ) ).

fof(addAssignment_1177,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4364(VarCurr,B)
      <=> v4353(VarCurr,B) ) ) ).

fof(addAssignment_1176,axiom,
    ! [VarCurr] :
      ( v4364(VarCurr,bitIndex3)
    <=> $false ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_112,axiom,
    ! [VarCurr] :
      ( ~ v291(VarCurr,bitIndex1)
     => ! [B] :
          ( range_2_0(B)
         => ( v4353(VarCurr,B)
          <=> $false ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_114,axiom,
    ! [VarCurr] :
      ( v291(VarCurr,bitIndex1)
     => ! [B] :
          ( range_2_0(B)
         => ( v4353(VarCurr,B)
          <=> v4363(VarCurr,B) ) ) ) ).

fof(addAssignment_1175,axiom,
    ! [VarCurr] :
      ( v4363(VarCurr,bitIndex0)
    <=> v4361(VarCurr) ) ).

fof(addAssignment_1174,axiom,
    ! [VarCurr] :
      ( ( v4363(VarCurr,bitIndex2)
      <=> v4355(VarCurr,bitIndex1) )
      & ( v4363(VarCurr,bitIndex1)
      <=> v4355(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1173,axiom,
    ! [VarCurr] :
      ( v4361(VarCurr)
    <=> v291(VarCurr,bitIndex0) ) ).

fof(addAssignment_1172,axiom,
    ! [VarCurr] :
      ( v291(VarCurr,bitIndex0)
    <=> v293(VarCurr,bitIndex0) ) ).

fof(addAssignment_1171,axiom,
    ! [VarCurr] :
      ( v293(VarCurr,bitIndex0)
    <=> v295(VarCurr,bitIndex16) ) ).

fof(addAssignment_1170,axiom,
    ! [VarCurr] :
      ( v295(VarCurr,bitIndex16)
    <=> v297(VarCurr,bitIndex16) ) ).

fof(addAssignment_1169,axiom,
    ! [VarCurr] :
      ( v297(VarCurr,bitIndex16)
    <=> v359(VarCurr,bitIndex16) ) ).

fof(addAssignment_1168,axiom,
    ! [VarCurr,B] :
      ( range_1_0(B)
     => ( v4355(VarCurr,B)
      <=> v4357(VarCurr,B) ) ) ).

fof(addAssignment_1167,axiom,
    ! [VarCurr,B] :
      ( range_1_0(B)
     => ( v4357(VarCurr,B)
      <=> v4359(VarCurr,B) ) ) ).

fof(addAssignment_1166,axiom,
    ! [VarCurr] :
      ( ( v4359(VarCurr,bitIndex1)
      <=> v502(VarCurr,bitIndex2) )
      & ( v4359(VarCurr,bitIndex0)
      <=> v502(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1165,axiom,
    ! [VarCurr,B] :
      ( range_2_1(B)
     => ( v502(VarCurr,B)
      <=> v490(VarCurr,B) ) ) ).

fof(addAssignment_1164,axiom,
    ! [VarCurr,B] :
      ( range_2_1(B)
     => ( v490(VarCurr,B)
      <=> v295(VarCurr,B) ) ) ).

fof(addAssignment_1163,axiom,
    ! [VarCurr,B] :
      ( range_2_1(B)
     => ( v295(VarCurr,B)
      <=> v297(VarCurr,B) ) ) ).

fof(addAssignment_1162,axiom,
    ! [VarCurr,B] :
      ( range_2_1(B)
     => ( v297(VarCurr,B)
      <=> v359(VarCurr,B) ) ) ).

fof(range_axiom_25,axiom,
    ! [B] :
      ( range_2_1(B)
    <=> ( $false
        | bitIndex1 = B
        | bitIndex2 = B ) ) ).

fof(addAssignment_1161,axiom,
    ! [VarCurr] :
      ( v4288(VarCurr)
    <=> v4290(VarCurr,bitIndex3) ) ).

fof(addAssignment_1160,axiom,
    ! [VarCurr] :
      ( v4290(VarCurr,bitIndex3)
    <=> v4304(VarCurr,bitIndex3) ) ).

fof(addAssignment_1159,axiom,
    ! [VarNext] :
      ( v2440(VarNext,bitIndex2)
    <=> v4337(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_74,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4338(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v4337(VarNext,B)
            <=> v2440(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_84,axiom,
    ! [VarNext] :
      ( v4338(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v4337(VarNext,B)
          <=> v4301(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_819,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4338(VarNext)
      <=> v4339(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_818,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4339(VarNext)
      <=> ( v4341(VarNext)
          & v2404(VarNext) ) ) ) ).

fof(writeUnaryOperator_341,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4341(VarNext)
      <=> v2411(VarNext) ) ) ).

fof(addAssignment_1158,axiom,
    ! [VarCurr] :
      ( v4290(VarCurr,bitIndex2)
    <=> v4304(VarCurr,bitIndex2) ) ).

fof(addAssignment_1157,axiom,
    ! [VarNext] :
      ( v2440(VarNext,bitIndex1)
    <=> v4329(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_73,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4330(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v4329(VarNext,B)
            <=> v2440(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_83,axiom,
    ! [VarNext] :
      ( v4330(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v4329(VarNext,B)
          <=> v4301(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_817,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4330(VarNext)
      <=> v4331(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_816,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4331(VarNext)
      <=> ( v4333(VarNext)
          & v2404(VarNext) ) ) ) ).

fof(writeUnaryOperator_340,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4333(VarNext)
      <=> v2411(VarNext) ) ) ).

fof(addAssignment_1156,axiom,
    ! [VarCurr] :
      ( v4290(VarCurr,bitIndex1)
    <=> v4304(VarCurr,bitIndex1) ) ).

fof(addAssignment_1155,axiom,
    ! [VarNext] :
      ( v2440(VarNext,bitIndex0)
    <=> v4321(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_72,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4322(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v4321(VarNext,B)
            <=> v2440(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_82,axiom,
    ! [VarNext] :
      ( v4322(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v4321(VarNext,B)
          <=> v4301(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_815,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4322(VarNext)
      <=> v4323(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_814,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4323(VarNext)
      <=> ( v4325(VarNext)
          & v2404(VarNext) ) ) ) ).

fof(writeUnaryOperator_339,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4325(VarNext)
      <=> v2411(VarNext) ) ) ).

fof(addAssignment_1154,axiom,
    ! [VarCurr] :
      ( v4290(VarCurr,bitIndex0)
    <=> v4304(VarCurr,bitIndex0) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_111,axiom,
    ! [VarCurr] :
      ( ~ v4305(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4304(VarCurr,B)
          <=> v4307(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_113,axiom,
    ! [VarCurr] :
      ( v4305(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4304(VarCurr,B)
          <=> v4306(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_15,axiom,
    ! [VarCurr] :
      ( ( ~ v4308(VarCurr)
        & ~ v4310(VarCurr)
        & ~ v4314(VarCurr) )
     => ! [B] :
          ( range_6_0(B)
         => ( v4307(VarCurr,B)
          <=> v2440(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_30,axiom,
    ! [VarCurr] :
      ( v4314(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4307(VarCurr,B)
          <=> v4316(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_79,axiom,
    ! [VarCurr] :
      ( v4310(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4307(VarCurr,B)
          <=> v4312(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_77,axiom,
    ! [VarCurr] :
      ( v4308(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4307(VarCurr,B)
          <=> v2440(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_248,axiom,
    ! [VarCurr] :
      ( v4318(VarCurr)
    <=> ( ( v4319(VarCurr,bitIndex1)
        <=> $true )
        & ( v4319(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1153,axiom,
    ! [VarCurr] :
      ( v4319(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1152,axiom,
    ! [VarCurr] :
      ( v4319(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(addAssignment_1151,axiom,
    ! [VarCurr] :
      ( v4316(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_1150,axiom,
    ! [VarCurr] :
      ( ( v4316(VarCurr,bitIndex6)
      <=> v2440(VarCurr,bitIndex5) )
      & ( v4316(VarCurr,bitIndex5)
      <=> v2440(VarCurr,bitIndex4) )
      & ( v4316(VarCurr,bitIndex4)
      <=> v2440(VarCurr,bitIndex3) )
      & ( v4316(VarCurr,bitIndex3)
      <=> v2440(VarCurr,bitIndex2) )
      & ( v4316(VarCurr,bitIndex2)
      <=> v2440(VarCurr,bitIndex1) )
      & ( v4316(VarCurr,bitIndex1)
      <=> v2440(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_247,axiom,
    ! [VarCurr] :
      ( v4314(VarCurr)
    <=> ( ( v4315(VarCurr,bitIndex1)
        <=> $true )
        & ( v4315(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1149,axiom,
    ! [VarCurr] :
      ( v4315(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1148,axiom,
    ! [VarCurr] :
      ( v4315(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(addAssignment_1147,axiom,
    ! [VarCurr] :
      ( ( v4312(VarCurr,bitIndex5)
      <=> v2440(VarCurr,bitIndex6) )
      & ( v4312(VarCurr,bitIndex4)
      <=> v2440(VarCurr,bitIndex5) )
      & ( v4312(VarCurr,bitIndex3)
      <=> v2440(VarCurr,bitIndex4) )
      & ( v4312(VarCurr,bitIndex2)
      <=> v2440(VarCurr,bitIndex3) )
      & ( v4312(VarCurr,bitIndex1)
      <=> v2440(VarCurr,bitIndex2) )
      & ( v4312(VarCurr,bitIndex0)
      <=> v2440(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_1146,axiom,
    ! [VarCurr] :
      ( v4312(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_246,axiom,
    ! [VarCurr] :
      ( v4310(VarCurr)
    <=> ( ( v4311(VarCurr,bitIndex1)
        <=> $false )
        & ( v4311(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1145,axiom,
    ! [VarCurr] :
      ( v4311(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1144,axiom,
    ! [VarCurr] :
      ( v4311(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_245,axiom,
    ! [VarCurr] :
      ( v4308(VarCurr)
    <=> ( ( v4309(VarCurr,bitIndex1)
        <=> $false )
        & ( v4309(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1143,axiom,
    ! [VarCurr] :
      ( v4309(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_1142,axiom,
    ! [VarCurr] :
      ( v4309(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(addAssignment_1141,axiom,
    ! [VarCurr] :
      ( v4306(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_1140,axiom,
    ! [VarCurr,B] :
      ( range_6_1(B)
     => ( v4306(VarCurr,B)
      <=> v2438(VarCurr,B) ) ) ).

fof(writeUnaryOperator_338,axiom,
    ! [VarCurr] :
      ( ~ v4305(VarCurr)
    <=> v2374(VarCurr) ) ).

fof(addAssignment_1139,axiom,
    ! [VarCurr] :
      ( v2438(VarCurr,bitIndex1)
    <=> v2439(VarCurr,bitIndex1) ) ).

fof(addAssignment_1138,axiom,
    ! [VarCurr] :
      ( v2438(VarCurr,bitIndex2)
    <=> v2439(VarCurr,bitIndex2) ) ).

fof(addAssignment_1137,axiom,
    ! [VarCurr] :
      ( v2438(VarCurr,bitIndex3)
    <=> v2439(VarCurr,bitIndex3) ) ).

fof(addAssignment_1136,axiom,
    ! [VarNext] :
      ( v2440(VarNext,bitIndex3)
    <=> v4292(VarNext,bitIndex3) ) ).

fof(addCaseBooleanConditionEqualRanges1_71,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4293(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v4292(VarNext,B)
            <=> v2440(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_81,axiom,
    ! [VarNext] :
      ( v4293(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v4292(VarNext,B)
          <=> v4301(VarNext,B) ) ) ) ).

fof(addAssignment_1135,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v4301(VarNext,B)
          <=> v4299(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_110,axiom,
    ! [VarCurr] :
      ( ~ v2418(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4299(VarCurr,B)
          <=> v4290(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_112,axiom,
    ! [VarCurr] :
      ( v2418(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4299(VarCurr,B)
          <=> b0000001(B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_813,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4293(VarNext)
      <=> v4294(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_812,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4294(VarNext)
      <=> ( v4296(VarNext)
          & v2404(VarNext) ) ) ) ).

fof(writeUnaryOperator_337,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4296(VarNext)
      <=> v2411(VarNext) ) ) ).

fof(addAssignment_1134,axiom,
    ! [VarCurr,B] :
      ( range_6_0(B)
     => ( v3196(VarCurr,B)
      <=> v3198(VarCurr,B) ) ) ).

fof(addAssignment_1133,axiom,
    ! [VarCurr,B] :
      ( range_6_0(B)
     => ( v3198(VarCurr,B)
      <=> v3200(VarCurr,B) ) ) ).

fof(addAssignment_1132,axiom,
    ! [VarCurr] :
      ( ( v3200(VarCurr,bitIndex6)
      <=> v3202(VarCurr,bitIndex27) )
      & ( v3200(VarCurr,bitIndex5)
      <=> v3202(VarCurr,bitIndex26) )
      & ( v3200(VarCurr,bitIndex4)
      <=> v3202(VarCurr,bitIndex25) )
      & ( v3200(VarCurr,bitIndex3)
      <=> v3202(VarCurr,bitIndex24) )
      & ( v3200(VarCurr,bitIndex2)
      <=> v3202(VarCurr,bitIndex23) )
      & ( v3200(VarCurr,bitIndex1)
      <=> v3202(VarCurr,bitIndex22) )
      & ( v3200(VarCurr,bitIndex0)
      <=> v3202(VarCurr,bitIndex21) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_70,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4245(VarNext)
       => ! [B] :
            ( range_27_21(B)
           => ( v3202(VarNext,B)
            <=> v3202(VarCurr,B) ) ) ) ) ).

fof(range_axiom_24,axiom,
    ! [B] :
      ( range_27_21(B)
    <=> ( $false
        | bitIndex21 = B
        | bitIndex22 = B
        | bitIndex23 = B
        | bitIndex24 = B
        | bitIndex25 = B
        | bitIndex26 = B
        | bitIndex27 = B ) ) ).

fof(addCaseBooleanConditionShiftedRanges0_2,axiom,
    ! [VarNext] :
      ( v4245(VarNext)
     => ( ( v3202(VarNext,bitIndex27)
        <=> v4271(VarNext,bitIndex6) )
        & ( v3202(VarNext,bitIndex26)
        <=> v4271(VarNext,bitIndex5) )
        & ( v3202(VarNext,bitIndex25)
        <=> v4271(VarNext,bitIndex4) )
        & ( v3202(VarNext,bitIndex24)
        <=> v4271(VarNext,bitIndex3) )
        & ( v3202(VarNext,bitIndex23)
        <=> v4271(VarNext,bitIndex2) )
        & ( v3202(VarNext,bitIndex22)
        <=> v4271(VarNext,bitIndex1) )
        & ( v3202(VarNext,bitIndex21)
        <=> v4271(VarNext,bitIndex0) ) ) ) ).

fof(addAssignment_1131,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v4271(VarNext,B)
          <=> v4269(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_78,axiom,
    ! [VarCurr] :
      ( ~ v4162(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4269(VarCurr,B)
          <=> v4272(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_76,axiom,
    ! [VarCurr] :
      ( v4162(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4269(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_29,axiom,
    ! [VarCurr] :
      ( ( ~ v4258(VarCurr)
        & ~ v4260(VarCurr) )
     => ! [B] :
          ( range_6_0(B)
         => ( v4272(VarCurr,B)
          <=> v4237(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_77,axiom,
    ! [VarCurr] :
      ( v4260(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4272(VarCurr,B)
          <=> v4230(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0_1,axiom,
    ! [VarCurr] :
      ( v4258(VarCurr)
     => ( ( v4272(VarCurr,bitIndex6)
        <=> v3202(VarCurr,bitIndex20) )
        & ( v4272(VarCurr,bitIndex5)
        <=> v3202(VarCurr,bitIndex19) )
        & ( v4272(VarCurr,bitIndex4)
        <=> v3202(VarCurr,bitIndex18) )
        & ( v4272(VarCurr,bitIndex3)
        <=> v3202(VarCurr,bitIndex17) )
        & ( v4272(VarCurr,bitIndex2)
        <=> v3202(VarCurr,bitIndex16) )
        & ( v4272(VarCurr,bitIndex1)
        <=> v3202(VarCurr,bitIndex15) )
        & ( v4272(VarCurr,bitIndex0)
        <=> v3202(VarCurr,bitIndex14) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_811,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4245(VarNext)
      <=> ( v4246(VarNext)
          & v4253(VarNext) ) ) ) ).

fof(addAssignment_1130,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4253(VarNext)
      <=> v4251(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_810,axiom,
    ! [VarCurr] :
      ( v4251(VarCurr)
    <=> ( v4254(VarCurr)
        & v4265(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_809,axiom,
    ! [VarCurr] :
      ( v4265(VarCurr)
    <=> ( v4266(VarCurr)
        | v4162(VarCurr) ) ) ).

fof(writeUnaryOperator_336,axiom,
    ! [VarCurr] :
      ( ~ v4266(VarCurr)
    <=> v4267(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_244,axiom,
    ! [VarCurr] :
      ( v4267(VarCurr)
    <=> ( ( v4268(VarCurr,bitIndex1)
        <=> $false )
        & ( v4268(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1129,axiom,
    ! [VarCurr] :
      ( v4268(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_1128,axiom,
    ! [VarCurr] :
      ( v4268(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_808,axiom,
    ! [VarCurr] :
      ( v4254(VarCurr)
    <=> ( v4162(VarCurr)
        | v4255(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_807,axiom,
    ! [VarCurr] :
      ( v4255(VarCurr)
    <=> ( v4256(VarCurr)
        & v4264(VarCurr) ) ) ).

fof(writeUnaryOperator_335,axiom,
    ! [VarCurr] :
      ( ~ v4264(VarCurr)
    <=> v4162(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_806,axiom,
    ! [VarCurr] :
      ( v4256(VarCurr)
    <=> ( v4257(VarCurr)
        | v4262(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_243,axiom,
    ! [VarCurr] :
      ( v4262(VarCurr)
    <=> ( ( v4263(VarCurr,bitIndex1)
        <=> $true )
        & ( v4263(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1127,axiom,
    ! [VarCurr] :
      ( v4263(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_1126,axiom,
    ! [VarCurr] :
      ( v4263(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_805,axiom,
    ! [VarCurr] :
      ( v4257(VarCurr)
    <=> ( v4258(VarCurr)
        | v4260(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_242,axiom,
    ! [VarCurr] :
      ( v4260(VarCurr)
    <=> ( ( v4261(VarCurr,bitIndex1)
        <=> $true )
        & ( v4261(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1125,axiom,
    ! [VarCurr] :
      ( v4261(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_1124,axiom,
    ! [VarCurr] :
      ( v4261(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_241,axiom,
    ! [VarCurr] :
      ( v4258(VarCurr)
    <=> ( ( v4259(VarCurr,bitIndex1)
        <=> $false )
        & ( v4259(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1123,axiom,
    ! [VarCurr] :
      ( v4259(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_1122,axiom,
    ! [VarCurr] :
      ( v4259(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_804,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4246(VarNext)
      <=> ( v4248(VarNext)
          & v166(VarNext) ) ) ) ).

fof(writeUnaryOperator_334,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4248(VarNext)
      <=> v179(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_109,axiom,
    ! [VarCurr] :
      ( ~ v4239(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4237(VarCurr,B)
          <=> v4241(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_111,axiom,
    ! [VarCurr] :
      ( v4239(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4237(VarCurr,B)
          <=> v3265(VarCurr,B) ) ) ) ).

fof(addAssignment_1121,axiom,
    ! [VarCurr] :
      ( ( v4241(VarCurr,bitIndex6)
      <=> v3202(VarCurr,bitIndex20) )
      & ( v4241(VarCurr,bitIndex5)
      <=> v3202(VarCurr,bitIndex19) )
      & ( v4241(VarCurr,bitIndex4)
      <=> v3202(VarCurr,bitIndex18) )
      & ( v4241(VarCurr,bitIndex3)
      <=> v3202(VarCurr,bitIndex17) )
      & ( v4241(VarCurr,bitIndex2)
      <=> v3202(VarCurr,bitIndex16) )
      & ( v4241(VarCurr,bitIndex1)
      <=> v3202(VarCurr,bitIndex15) )
      & ( v4241(VarCurr,bitIndex0)
      <=> v3202(VarCurr,bitIndex14) ) ) ).

fof(addAssignment_1120,axiom,
    ! [VarCurr] :
      ( v4239(VarCurr)
    <=> v3209(VarCurr,bitIndex1) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_108,axiom,
    ! [VarCurr] :
      ( ~ v4232(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4230(VarCurr,B)
          <=> v4234(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_110,axiom,
    ! [VarCurr] :
      ( v4232(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4230(VarCurr,B)
          <=> v3265(VarCurr,B) ) ) ) ).

fof(addAssignment_1119,axiom,
    ! [VarCurr] :
      ( ( v4234(VarCurr,bitIndex6)
      <=> v3202(VarCurr,bitIndex27) )
      & ( v4234(VarCurr,bitIndex5)
      <=> v3202(VarCurr,bitIndex26) )
      & ( v4234(VarCurr,bitIndex4)
      <=> v3202(VarCurr,bitIndex25) )
      & ( v4234(VarCurr,bitIndex3)
      <=> v3202(VarCurr,bitIndex24) )
      & ( v4234(VarCurr,bitIndex2)
      <=> v3202(VarCurr,bitIndex23) )
      & ( v4234(VarCurr,bitIndex1)
      <=> v3202(VarCurr,bitIndex22) )
      & ( v4234(VarCurr,bitIndex0)
      <=> v3202(VarCurr,bitIndex21) ) ) ).

fof(addAssignment_1118,axiom,
    ! [VarCurr] :
      ( v4232(VarCurr)
    <=> v3209(VarCurr,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_69,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4199(VarNext)
       => ! [B] :
            ( range_20_14(B)
           => ( v3202(VarNext,B)
            <=> v3202(VarCurr,B) ) ) ) ) ).

fof(range_axiom_23,axiom,
    ! [B] :
      ( range_20_14(B)
    <=> ( $false
        | bitIndex14 = B
        | bitIndex15 = B
        | bitIndex16 = B
        | bitIndex17 = B
        | bitIndex18 = B
        | bitIndex19 = B
        | bitIndex20 = B ) ) ).

fof(addCaseBooleanConditionShiftedRanges0_1,axiom,
    ! [VarNext] :
      ( v4199(VarNext)
     => ( ( v3202(VarNext,bitIndex20)
        <=> v4225(VarNext,bitIndex6) )
        & ( v3202(VarNext,bitIndex19)
        <=> v4225(VarNext,bitIndex5) )
        & ( v3202(VarNext,bitIndex18)
        <=> v4225(VarNext,bitIndex4) )
        & ( v3202(VarNext,bitIndex17)
        <=> v4225(VarNext,bitIndex3) )
        & ( v3202(VarNext,bitIndex16)
        <=> v4225(VarNext,bitIndex2) )
        & ( v3202(VarNext,bitIndex15)
        <=> v4225(VarNext,bitIndex1) )
        & ( v3202(VarNext,bitIndex14)
        <=> v4225(VarNext,bitIndex0) ) ) ) ).

fof(addAssignment_1117,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v4225(VarNext,B)
          <=> v4223(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_76,axiom,
    ! [VarCurr] :
      ( ~ v4162(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4223(VarCurr,B)
          <=> v4226(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_75,axiom,
    ! [VarCurr] :
      ( v4162(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4223(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_28,axiom,
    ! [VarCurr] :
      ( ( ~ v4212(VarCurr)
        & ~ v4214(VarCurr) )
     => ! [B] :
          ( range_6_0(B)
         => ( v4226(VarCurr,B)
          <=> v4191(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_75,axiom,
    ! [VarCurr] :
      ( v4214(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4226(VarCurr,B)
          <=> v4184(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionShiftedRanges0,axiom,
    ! [VarCurr] :
      ( v4212(VarCurr)
     => ( ( v4226(VarCurr,bitIndex6)
        <=> v3202(VarCurr,bitIndex13) )
        & ( v4226(VarCurr,bitIndex5)
        <=> v3202(VarCurr,bitIndex12) )
        & ( v4226(VarCurr,bitIndex4)
        <=> v3202(VarCurr,bitIndex11) )
        & ( v4226(VarCurr,bitIndex3)
        <=> v3202(VarCurr,bitIndex10) )
        & ( v4226(VarCurr,bitIndex2)
        <=> v3202(VarCurr,bitIndex9) )
        & ( v4226(VarCurr,bitIndex1)
        <=> v3202(VarCurr,bitIndex8) )
        & ( v4226(VarCurr,bitIndex0)
        <=> v3202(VarCurr,bitIndex7) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_803,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4199(VarNext)
      <=> ( v4200(VarNext)
          & v4207(VarNext) ) ) ) ).

fof(addAssignment_1116,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4207(VarNext)
      <=> v4205(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_802,axiom,
    ! [VarCurr] :
      ( v4205(VarCurr)
    <=> ( v4208(VarCurr)
        & v4219(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_801,axiom,
    ! [VarCurr] :
      ( v4219(VarCurr)
    <=> ( v4220(VarCurr)
        | v4162(VarCurr) ) ) ).

fof(writeUnaryOperator_333,axiom,
    ! [VarCurr] :
      ( ~ v4220(VarCurr)
    <=> v4221(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_240,axiom,
    ! [VarCurr] :
      ( v4221(VarCurr)
    <=> ( ( v4222(VarCurr,bitIndex1)
        <=> $false )
        & ( v4222(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1115,axiom,
    ! [VarCurr] :
      ( v4222(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_1114,axiom,
    ! [VarCurr] :
      ( v4222(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_800,axiom,
    ! [VarCurr] :
      ( v4208(VarCurr)
    <=> ( v4162(VarCurr)
        | v4209(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_799,axiom,
    ! [VarCurr] :
      ( v4209(VarCurr)
    <=> ( v4210(VarCurr)
        & v4218(VarCurr) ) ) ).

fof(writeUnaryOperator_332,axiom,
    ! [VarCurr] :
      ( ~ v4218(VarCurr)
    <=> v4162(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_798,axiom,
    ! [VarCurr] :
      ( v4210(VarCurr)
    <=> ( v4211(VarCurr)
        | v4216(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_239,axiom,
    ! [VarCurr] :
      ( v4216(VarCurr)
    <=> ( ( v4217(VarCurr,bitIndex1)
        <=> $true )
        & ( v4217(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1113,axiom,
    ! [VarCurr] :
      ( v4217(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_1112,axiom,
    ! [VarCurr] :
      ( v4217(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_797,axiom,
    ! [VarCurr] :
      ( v4211(VarCurr)
    <=> ( v4212(VarCurr)
        | v4214(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_238,axiom,
    ! [VarCurr] :
      ( v4214(VarCurr)
    <=> ( ( v4215(VarCurr,bitIndex1)
        <=> $true )
        & ( v4215(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1111,axiom,
    ! [VarCurr] :
      ( v4215(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_1110,axiom,
    ! [VarCurr] :
      ( v4215(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_237,axiom,
    ! [VarCurr] :
      ( v4212(VarCurr)
    <=> ( ( v4213(VarCurr,bitIndex1)
        <=> $false )
        & ( v4213(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1109,axiom,
    ! [VarCurr] :
      ( v4213(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_1108,axiom,
    ! [VarCurr] :
      ( v4213(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_796,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4200(VarNext)
      <=> ( v4202(VarNext)
          & v166(VarNext) ) ) ) ).

fof(writeUnaryOperator_331,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4202(VarNext)
      <=> v179(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_107,axiom,
    ! [VarCurr] :
      ( ~ v4193(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4191(VarCurr,B)
          <=> v4195(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_109,axiom,
    ! [VarCurr] :
      ( v4193(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4191(VarCurr,B)
          <=> v3265(VarCurr,B) ) ) ) ).

fof(addAssignment_1107,axiom,
    ! [VarCurr] :
      ( ( v4195(VarCurr,bitIndex6)
      <=> v3202(VarCurr,bitIndex13) )
      & ( v4195(VarCurr,bitIndex5)
      <=> v3202(VarCurr,bitIndex12) )
      & ( v4195(VarCurr,bitIndex4)
      <=> v3202(VarCurr,bitIndex11) )
      & ( v4195(VarCurr,bitIndex3)
      <=> v3202(VarCurr,bitIndex10) )
      & ( v4195(VarCurr,bitIndex2)
      <=> v3202(VarCurr,bitIndex9) )
      & ( v4195(VarCurr,bitIndex1)
      <=> v3202(VarCurr,bitIndex8) )
      & ( v4195(VarCurr,bitIndex0)
      <=> v3202(VarCurr,bitIndex7) ) ) ).

fof(addAssignment_1106,axiom,
    ! [VarCurr] :
      ( v4193(VarCurr)
    <=> v3209(VarCurr,bitIndex2) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_106,axiom,
    ! [VarCurr] :
      ( ~ v4186(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4184(VarCurr,B)
          <=> v4188(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_108,axiom,
    ! [VarCurr] :
      ( v4186(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4184(VarCurr,B)
          <=> v3265(VarCurr,B) ) ) ) ).

fof(addAssignment_1105,axiom,
    ! [VarCurr] :
      ( ( v4188(VarCurr,bitIndex6)
      <=> v3202(VarCurr,bitIndex20) )
      & ( v4188(VarCurr,bitIndex5)
      <=> v3202(VarCurr,bitIndex19) )
      & ( v4188(VarCurr,bitIndex4)
      <=> v3202(VarCurr,bitIndex18) )
      & ( v4188(VarCurr,bitIndex3)
      <=> v3202(VarCurr,bitIndex17) )
      & ( v4188(VarCurr,bitIndex2)
      <=> v3202(VarCurr,bitIndex16) )
      & ( v4188(VarCurr,bitIndex1)
      <=> v3202(VarCurr,bitIndex15) )
      & ( v4188(VarCurr,bitIndex0)
      <=> v3202(VarCurr,bitIndex14) ) ) ).

fof(addAssignment_1104,axiom,
    ! [VarCurr] :
      ( v4186(VarCurr)
    <=> v3209(VarCurr,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_68,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4152(VarNext)
       => ! [B] :
            ( range_13_7(B)
           => ( v3202(VarNext,B)
            <=> v3202(VarCurr,B) ) ) ) ) ).

fof(range_axiom_22,axiom,
    ! [B] :
      ( range_13_7(B)
    <=> ( $false
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B
        | bitIndex11 = B
        | bitIndex12 = B
        | bitIndex13 = B ) ) ).

fof(addCaseBooleanConditionShiftedRanges0,axiom,
    ! [VarNext] :
      ( v4152(VarNext)
     => ( ( v3202(VarNext,bitIndex13)
        <=> v4179(VarNext,bitIndex6) )
        & ( v3202(VarNext,bitIndex12)
        <=> v4179(VarNext,bitIndex5) )
        & ( v3202(VarNext,bitIndex11)
        <=> v4179(VarNext,bitIndex4) )
        & ( v3202(VarNext,bitIndex10)
        <=> v4179(VarNext,bitIndex3) )
        & ( v3202(VarNext,bitIndex9)
        <=> v4179(VarNext,bitIndex2) )
        & ( v3202(VarNext,bitIndex8)
        <=> v4179(VarNext,bitIndex1) )
        & ( v3202(VarNext,bitIndex7)
        <=> v4179(VarNext,bitIndex0) ) ) ) ).

fof(addAssignment_1103,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v4179(VarNext,B)
          <=> v4177(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_74,axiom,
    ! [VarCurr] :
      ( ~ v4162(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4177(VarCurr,B)
          <=> v4180(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_74,axiom,
    ! [VarCurr] :
      ( v4162(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4177(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_27,axiom,
    ! [VarCurr] :
      ( ( ~ v4166(VarCurr)
        & ~ v4168(VarCurr) )
     => ! [B] :
          ( range_6_0(B)
         => ( v4180(VarCurr,B)
          <=> v4144(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_73,axiom,
    ! [VarCurr] :
      ( v4168(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4180(VarCurr,B)
          <=> v3205(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_73,axiom,
    ! [VarCurr] :
      ( v4166(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4180(VarCurr,B)
          <=> v3202(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_795,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4152(VarNext)
      <=> ( v4153(VarNext)
          & v4160(VarNext) ) ) ) ).

fof(addAssignment_1102,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4160(VarNext)
      <=> v4158(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_794,axiom,
    ! [VarCurr] :
      ( v4158(VarCurr)
    <=> ( v4161(VarCurr)
        & v4173(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_793,axiom,
    ! [VarCurr] :
      ( v4173(VarCurr)
    <=> ( v4174(VarCurr)
        | v4162(VarCurr) ) ) ).

fof(writeUnaryOperator_330,axiom,
    ! [VarCurr] :
      ( ~ v4174(VarCurr)
    <=> v4175(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_236,axiom,
    ! [VarCurr] :
      ( v4175(VarCurr)
    <=> ( ( v4176(VarCurr,bitIndex1)
        <=> $false )
        & ( v4176(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1101,axiom,
    ! [VarCurr] :
      ( v4176(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_1100,axiom,
    ! [VarCurr] :
      ( v4176(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_792,axiom,
    ! [VarCurr] :
      ( v4161(VarCurr)
    <=> ( v4162(VarCurr)
        | v4163(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_791,axiom,
    ! [VarCurr] :
      ( v4163(VarCurr)
    <=> ( v4164(VarCurr)
        & v4172(VarCurr) ) ) ).

fof(writeUnaryOperator_329,axiom,
    ! [VarCurr] :
      ( ~ v4172(VarCurr)
    <=> v4162(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_790,axiom,
    ! [VarCurr] :
      ( v4164(VarCurr)
    <=> ( v4165(VarCurr)
        | v4170(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_235,axiom,
    ! [VarCurr] :
      ( v4170(VarCurr)
    <=> ( ( v4171(VarCurr,bitIndex1)
        <=> $true )
        & ( v4171(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1099,axiom,
    ! [VarCurr] :
      ( v4171(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_1098,axiom,
    ! [VarCurr] :
      ( v4171(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_789,axiom,
    ! [VarCurr] :
      ( v4165(VarCurr)
    <=> ( v4166(VarCurr)
        | v4168(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_234,axiom,
    ! [VarCurr] :
      ( v4168(VarCurr)
    <=> ( ( v4169(VarCurr,bitIndex1)
        <=> $true )
        & ( v4169(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1097,axiom,
    ! [VarCurr] :
      ( v4169(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_1096,axiom,
    ! [VarCurr] :
      ( v4169(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_233,axiom,
    ! [VarCurr] :
      ( v4166(VarCurr)
    <=> ( ( v4167(VarCurr,bitIndex1)
        <=> $false )
        & ( v4167(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1095,axiom,
    ! [VarCurr] :
      ( v4167(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_1094,axiom,
    ! [VarCurr] :
      ( v4167(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(writeUnaryOperator_328,axiom,
    ! [VarCurr] :
      ( ~ v4162(VarCurr)
    <=> v82(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_788,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4153(VarNext)
      <=> ( v4154(VarNext)
          & v166(VarNext) ) ) ) ).

fof(writeUnaryOperator_327,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4154(VarNext)
      <=> v179(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_105,axiom,
    ! [VarCurr] :
      ( ~ v4146(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4144(VarCurr,B)
          <=> v4148(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_107,axiom,
    ! [VarCurr] :
      ( v4146(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4144(VarCurr,B)
          <=> v3265(VarCurr,B) ) ) ) ).

fof(addAssignment_1093,axiom,
    ! [VarCurr,B] :
      ( range_6_0(B)
     => ( v4148(VarCurr,B)
      <=> v3202(VarCurr,B) ) ) ).

fof(addAssignment_1092,axiom,
    ! [VarCurr] :
      ( v4146(VarCurr)
    <=> v3209(VarCurr,bitIndex3) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_104,axiom,
    ! [VarCurr] :
      ( ~ v3207(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3205(VarCurr,B)
          <=> v4141(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_106,axiom,
    ! [VarCurr] :
      ( v3207(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3205(VarCurr,B)
          <=> v3265(VarCurr,B) ) ) ) ).

fof(addAssignment_1091,axiom,
    ! [VarCurr] :
      ( ( v4141(VarCurr,bitIndex6)
      <=> v3202(VarCurr,bitIndex13) )
      & ( v4141(VarCurr,bitIndex5)
      <=> v3202(VarCurr,bitIndex12) )
      & ( v4141(VarCurr,bitIndex4)
      <=> v3202(VarCurr,bitIndex11) )
      & ( v4141(VarCurr,bitIndex3)
      <=> v3202(VarCurr,bitIndex10) )
      & ( v4141(VarCurr,bitIndex2)
      <=> v3202(VarCurr,bitIndex9) )
      & ( v4141(VarCurr,bitIndex1)
      <=> v3202(VarCurr,bitIndex8) )
      & ( v4141(VarCurr,bitIndex0)
      <=> v3202(VarCurr,bitIndex7) ) ) ).

fof(addAssignmentInitValueVector_13,axiom,
    ( ( v3202(constB0,bitIndex27)
    <=> $false )
    & ( v3202(constB0,bitIndex26)
    <=> $false )
    & ( v3202(constB0,bitIndex25)
    <=> $false )
    & ( v3202(constB0,bitIndex24)
    <=> $false )
    & ( v3202(constB0,bitIndex23)
    <=> $false )
    & ( v3202(constB0,bitIndex22)
    <=> $false )
    & ( v3202(constB0,bitIndex21)
    <=> $false ) ) ).

fof(addAssignmentInitValueVector_12,axiom,
    ( ( v3202(constB0,bitIndex20)
    <=> $false )
    & ( v3202(constB0,bitIndex19)
    <=> $false )
    & ( v3202(constB0,bitIndex18)
    <=> $false )
    & ( v3202(constB0,bitIndex17)
    <=> $false )
    & ( v3202(constB0,bitIndex16)
    <=> $false )
    & ( v3202(constB0,bitIndex15)
    <=> $false )
    & ( v3202(constB0,bitIndex14)
    <=> $false ) ) ).

fof(addAssignment_1090,axiom,
    ! [VarCurr,B] :
      ( range_6_0(B)
     => ( v3265(VarCurr,B)
      <=> v3267(VarCurr,B) ) ) ).

fof(addAssignment_1089,axiom,
    ! [VarCurr] :
      ( ( v3267(VarCurr,bitIndex6)
      <=> v3269(VarCurr,bitIndex79) )
      & ( v3267(VarCurr,bitIndex5)
      <=> v3269(VarCurr,bitIndex78) )
      & ( v3267(VarCurr,bitIndex4)
      <=> v3269(VarCurr,bitIndex77) )
      & ( v3267(VarCurr,bitIndex3)
      <=> v3269(VarCurr,bitIndex76) )
      & ( v3267(VarCurr,bitIndex2)
      <=> v3269(VarCurr,bitIndex75) )
      & ( v3267(VarCurr,bitIndex1)
      <=> v3269(VarCurr,bitIndex74) )
      & ( v3267(VarCurr,bitIndex0)
      <=> v3269(VarCurr,bitIndex73) ) ) ).

fof(addAssignment_1088,axiom,
    ! [VarCurr,B] :
      ( range_79_73(B)
     => ( v3269(VarCurr,B)
      <=> v3271(VarCurr,B) ) ) ).

fof(addAssignment_1087,axiom,
    ! [VarCurr,B] :
      ( range_79_73(B)
     => ( v3271(VarCurr,B)
      <=> v3273(VarCurr,B) ) ) ).

fof(addAssignment_1086,axiom,
    ! [VarCurr,B] :
      ( range_79_73(B)
     => ( v3273(VarCurr,B)
      <=> v3275(VarCurr,B) ) ) ).

fof(addAssignment_1085,axiom,
    ! [VarCurr,B] :
      ( range_79_73(B)
     => ( v3275(VarCurr,B)
      <=> v3277(VarCurr,B) ) ) ).

fof(addAssignment_1084,axiom,
    ! [VarCurr,B] :
      ( range_79_73(B)
     => ( v3277(VarCurr,B)
      <=> v3279(VarCurr,B) ) ) ).

fof(addAssignment_1083,axiom,
    ! [VarCurr,B] :
      ( range_79_73(B)
     => ( v3279(VarCurr,B)
      <=> v3281(VarCurr,B) ) ) ).

fof(addAssignment_1082,axiom,
    ! [VarCurr,B] :
      ( range_79_73(B)
     => ( v3281(VarCurr,B)
      <=> v4121(VarCurr,B) ) ) ).

fof(range_axiom_21,axiom,
    ! [B] :
      ( range_79_73(B)
    <=> ( $false
        | bitIndex73 = B
        | bitIndex74 = B
        | bitIndex75 = B
        | bitIndex76 = B
        | bitIndex77 = B
        | bitIndex78 = B
        | bitIndex79 = B ) ) ).

fof(addAssignment_1081,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v4121(VarCurr,B)
      <=> v4138(VarCurr,B) ) ) ).

fof(addAssignment_1080,axiom,
    ! [VarCurr] :
      ( ( v4121(VarCurr,bitIndex9)
      <=> v4136(VarCurr,bitIndex4) )
      & ( v4121(VarCurr,bitIndex8)
      <=> v4136(VarCurr,bitIndex3) )
      & ( v4121(VarCurr,bitIndex7)
      <=> v4136(VarCurr,bitIndex2) )
      & ( v4121(VarCurr,bitIndex6)
      <=> v4136(VarCurr,bitIndex1) )
      & ( v4121(VarCurr,bitIndex5)
      <=> v4136(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1079,axiom,
    ! [VarCurr] :
      ( ( v4121(VarCurr,bitIndex15)
      <=> v4134(VarCurr,bitIndex5) )
      & ( v4121(VarCurr,bitIndex14)
      <=> v4134(VarCurr,bitIndex4) )
      & ( v4121(VarCurr,bitIndex13)
      <=> v4134(VarCurr,bitIndex3) )
      & ( v4121(VarCurr,bitIndex12)
      <=> v4134(VarCurr,bitIndex2) )
      & ( v4121(VarCurr,bitIndex11)
      <=> v4134(VarCurr,bitIndex1) )
      & ( v4121(VarCurr,bitIndex10)
      <=> v4134(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1078,axiom,
    ! [VarCurr] :
      ( ( v4121(VarCurr,bitIndex20)
      <=> v4132(VarCurr,bitIndex4) )
      & ( v4121(VarCurr,bitIndex19)
      <=> v4132(VarCurr,bitIndex3) )
      & ( v4121(VarCurr,bitIndex18)
      <=> v4132(VarCurr,bitIndex2) )
      & ( v4121(VarCurr,bitIndex17)
      <=> v4132(VarCurr,bitIndex1) )
      & ( v4121(VarCurr,bitIndex16)
      <=> v4132(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1077,axiom,
    ! [VarCurr] :
      ( ( v4121(VarCurr,bitIndex54)
      <=> v4130(VarCurr,bitIndex33) )
      & ( v4121(VarCurr,bitIndex53)
      <=> v4130(VarCurr,bitIndex32) )
      & ( v4121(VarCurr,bitIndex52)
      <=> v4130(VarCurr,bitIndex31) )
      & ( v4121(VarCurr,bitIndex51)
      <=> v4130(VarCurr,bitIndex30) )
      & ( v4121(VarCurr,bitIndex50)
      <=> v4130(VarCurr,bitIndex29) )
      & ( v4121(VarCurr,bitIndex49)
      <=> v4130(VarCurr,bitIndex28) )
      & ( v4121(VarCurr,bitIndex48)
      <=> v4130(VarCurr,bitIndex27) )
      & ( v4121(VarCurr,bitIndex47)
      <=> v4130(VarCurr,bitIndex26) )
      & ( v4121(VarCurr,bitIndex46)
      <=> v4130(VarCurr,bitIndex25) )
      & ( v4121(VarCurr,bitIndex45)
      <=> v4130(VarCurr,bitIndex24) )
      & ( v4121(VarCurr,bitIndex44)
      <=> v4130(VarCurr,bitIndex23) )
      & ( v4121(VarCurr,bitIndex43)
      <=> v4130(VarCurr,bitIndex22) )
      & ( v4121(VarCurr,bitIndex42)
      <=> v4130(VarCurr,bitIndex21) )
      & ( v4121(VarCurr,bitIndex41)
      <=> v4130(VarCurr,bitIndex20) )
      & ( v4121(VarCurr,bitIndex40)
      <=> v4130(VarCurr,bitIndex19) )
      & ( v4121(VarCurr,bitIndex39)
      <=> v4130(VarCurr,bitIndex18) )
      & ( v4121(VarCurr,bitIndex38)
      <=> v4130(VarCurr,bitIndex17) )
      & ( v4121(VarCurr,bitIndex37)
      <=> v4130(VarCurr,bitIndex16) )
      & ( v4121(VarCurr,bitIndex36)
      <=> v4130(VarCurr,bitIndex15) )
      & ( v4121(VarCurr,bitIndex35)
      <=> v4130(VarCurr,bitIndex14) )
      & ( v4121(VarCurr,bitIndex34)
      <=> v4130(VarCurr,bitIndex13) )
      & ( v4121(VarCurr,bitIndex33)
      <=> v4130(VarCurr,bitIndex12) )
      & ( v4121(VarCurr,bitIndex32)
      <=> v4130(VarCurr,bitIndex11) )
      & ( v4121(VarCurr,bitIndex31)
      <=> v4130(VarCurr,bitIndex10) )
      & ( v4121(VarCurr,bitIndex30)
      <=> v4130(VarCurr,bitIndex9) )
      & ( v4121(VarCurr,bitIndex29)
      <=> v4130(VarCurr,bitIndex8) )
      & ( v4121(VarCurr,bitIndex28)
      <=> v4130(VarCurr,bitIndex7) )
      & ( v4121(VarCurr,bitIndex27)
      <=> v4130(VarCurr,bitIndex6) )
      & ( v4121(VarCurr,bitIndex26)
      <=> v4130(VarCurr,bitIndex5) )
      & ( v4121(VarCurr,bitIndex25)
      <=> v4130(VarCurr,bitIndex4) )
      & ( v4121(VarCurr,bitIndex24)
      <=> v4130(VarCurr,bitIndex3) )
      & ( v4121(VarCurr,bitIndex23)
      <=> v4130(VarCurr,bitIndex2) )
      & ( v4121(VarCurr,bitIndex22)
      <=> v4130(VarCurr,bitIndex1) )
      & ( v4121(VarCurr,bitIndex21)
      <=> v4130(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1076,axiom,
    ! [VarCurr] :
      ( ( v4121(VarCurr,bitIndex58)
      <=> v4126(VarCurr,bitIndex3) )
      & ( v4121(VarCurr,bitIndex57)
      <=> v4126(VarCurr,bitIndex2) )
      & ( v4121(VarCurr,bitIndex56)
      <=> v4126(VarCurr,bitIndex1) )
      & ( v4121(VarCurr,bitIndex55)
      <=> v4126(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1075,axiom,
    ! [VarCurr] :
      ( ( v4121(VarCurr,bitIndex62)
      <=> v4124(VarCurr,bitIndex3) )
      & ( v4121(VarCurr,bitIndex61)
      <=> v4124(VarCurr,bitIndex2) )
      & ( v4121(VarCurr,bitIndex60)
      <=> v4124(VarCurr,bitIndex1) )
      & ( v4121(VarCurr,bitIndex59)
      <=> v4124(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1074,axiom,
    ! [VarCurr] :
      ( ( v4121(VarCurr,bitIndex72)
      <=> v4122(VarCurr,bitIndex9) )
      & ( v4121(VarCurr,bitIndex71)
      <=> v4122(VarCurr,bitIndex8) )
      & ( v4121(VarCurr,bitIndex70)
      <=> v4122(VarCurr,bitIndex7) )
      & ( v4121(VarCurr,bitIndex69)
      <=> v4122(VarCurr,bitIndex6) )
      & ( v4121(VarCurr,bitIndex68)
      <=> v4122(VarCurr,bitIndex5) )
      & ( v4121(VarCurr,bitIndex67)
      <=> v4122(VarCurr,bitIndex4) )
      & ( v4121(VarCurr,bitIndex66)
      <=> v4122(VarCurr,bitIndex3) )
      & ( v4121(VarCurr,bitIndex65)
      <=> v4122(VarCurr,bitIndex2) )
      & ( v4121(VarCurr,bitIndex64)
      <=> v4122(VarCurr,bitIndex1) )
      & ( v4121(VarCurr,bitIndex63)
      <=> v4122(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_1073,axiom,
    ! [VarCurr] :
      ( ( v4121(VarCurr,bitIndex79)
      <=> v3283(VarCurr,bitIndex6) )
      & ( v4121(VarCurr,bitIndex78)
      <=> v3283(VarCurr,bitIndex5) )
      & ( v4121(VarCurr,bitIndex77)
      <=> v3283(VarCurr,bitIndex4) )
      & ( v4121(VarCurr,bitIndex76)
      <=> v3283(VarCurr,bitIndex3) )
      & ( v4121(VarCurr,bitIndex75)
      <=> v3283(VarCurr,bitIndex2) )
      & ( v4121(VarCurr,bitIndex74)
      <=> v3283(VarCurr,bitIndex1) )
      & ( v4121(VarCurr,bitIndex73)
      <=> v3283(VarCurr,bitIndex0) ) ) ).

fof(addAssignmentInitValue_21,axiom,
    ~ v4126(constB0,bitIndex2) ).

fof(addAssignmentInitValue_20,axiom,
    ~ v4126(constB0,bitIndex1) ).

fof(addAssignmentInitValue_19,axiom,
    ~ v4126(constB0,bitIndex0) ).

fof(bitBlastConstant_378,axiom,
    ~ bx000(bitIndex2) ).

fof(bitBlastConstant_377,axiom,
    ~ bx000(bitIndex1) ).

fof(bitBlastConstant_376,axiom,
    ~ bx000(bitIndex0) ).

fof(addCaseBooleanConditionEqualRanges1_67,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4102(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v3283(VarNext,B)
            <=> v3283(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_80,axiom,
    ! [VarNext] :
      ( v4102(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v3283(VarNext,B)
          <=> v4118(VarNext,B) ) ) ) ).

fof(addAssignment_1072,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v4118(VarNext,B)
          <=> v4116(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_72,axiom,
    ! [VarCurr] :
      ( ~ v4113(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4116(VarCurr,B)
          <=> v3296(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_72,axiom,
    ! [VarCurr] :
      ( v4113(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4116(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_787,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4102(VarNext)
      <=> ( v4103(VarNext)
          & v4112(VarNext) ) ) ) ).

fof(addAssignment_1071,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4112(VarNext)
      <=> v4110(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_786,axiom,
    ! [VarCurr] :
      ( v4110(VarCurr)
    <=> ( v4113(VarCurr)
        | v4114(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_785,axiom,
    ! [VarCurr] :
      ( v4114(VarCurr)
    <=> ( v3287(VarCurr)
        & v4115(VarCurr) ) ) ).

fof(writeUnaryOperator_326,axiom,
    ! [VarCurr] :
      ( ~ v4115(VarCurr)
    <=> v4113(VarCurr) ) ).

fof(writeUnaryOperator_325,axiom,
    ! [VarCurr] :
      ( ~ v4113(VarCurr)
    <=> v3285(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_784,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4103(VarNext)
      <=> ( v4104(VarNext)
          & v4099(VarNext) ) ) ) ).

fof(writeUnaryOperator_324,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4104(VarNext)
      <=> v4106(VarNext) ) ) ).

fof(addAssignment_1070,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4106(VarNext)
      <=> v4099(VarCurr) ) ) ).

fof(addAssignmentInitValueVector_11,axiom,
    ! [B] :
      ( range_6_0(B)
     => ( v3283(constB0,B)
      <=> $false ) ) ).

fof(addAssignment_1069,axiom,
    ! [VarCurr] :
      ( v4099(VarCurr)
    <=> v303(VarCurr) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_26,axiom,
    ! [VarCurr] :
      ( ( ~ v4093(VarCurr)
        & ~ v4094(VarCurr) )
     => ! [B] :
          ( range_6_0(B)
         => ( v3296(VarCurr,B)
          <=> v4001(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_71,axiom,
    ! [VarCurr] :
      ( v4094(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3296(VarCurr,B)
          <=> v3312(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_71,axiom,
    ! [VarCurr] :
      ( v4093(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3296(VarCurr,B)
          <=> v3307(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_783,axiom,
    ! [VarCurr] :
      ( v4095(VarCurr)
    <=> ( v4096(VarCurr)
        | v4097(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_232,axiom,
    ! [VarCurr] :
      ( v4097(VarCurr)
    <=> ( ( v3298(VarCurr,bitIndex1)
        <=> $true )
        & ( v3298(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_231,axiom,
    ! [VarCurr] :
      ( v4096(VarCurr)
    <=> ( ( v3298(VarCurr,bitIndex1)
        <=> $true )
        & ( v3298(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_230,axiom,
    ! [VarCurr] :
      ( v4094(VarCurr)
    <=> ( ( v3298(VarCurr,bitIndex1)
        <=> $false )
        & ( v3298(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_229,axiom,
    ! [VarCurr] :
      ( v4093(VarCurr)
    <=> ( ( v3298(VarCurr,bitIndex1)
        <=> $false )
        & ( v3298(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_103,axiom,
    ! [VarCurr] :
      ( ~ v4086(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4001(VarCurr,B)
          <=> $false ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_105,axiom,
    ! [VarCurr] :
      ( v4086(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4001(VarCurr,B)
          <=> v4091(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_70,axiom,
    ! [VarCurr] :
      ( ~ v4087(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4091(VarCurr,B)
          <=> b0001011(B) ) ) ) ).

fof(bitBlastConstant_375,axiom,
    ~ b0001011(bitIndex6) ).

fof(bitBlastConstant_374,axiom,
    ~ b0001011(bitIndex5) ).

fof(bitBlastConstant_373,axiom,
    ~ b0001011(bitIndex4) ).

fof(bitBlastConstant_372,axiom,
    b0001011(bitIndex3) ).

fof(bitBlastConstant_371,axiom,
    ~ b0001011(bitIndex2) ).

fof(bitBlastConstant_370,axiom,
    b0001011(bitIndex1) ).

fof(bitBlastConstant_369,axiom,
    b0001011(bitIndex0) ).

fof(addParallelCaseBooleanConditionEqualRanges0_70,axiom,
    ! [VarCurr] :
      ( v4087(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v4091(VarCurr,B)
          <=> b0001010(B) ) ) ) ).

fof(bitBlastConstant_368,axiom,
    ~ b0001010(bitIndex6) ).

fof(bitBlastConstant_367,axiom,
    ~ b0001010(bitIndex5) ).

fof(bitBlastConstant_366,axiom,
    ~ b0001010(bitIndex4) ).

fof(bitBlastConstant_365,axiom,
    b0001010(bitIndex3) ).

fof(bitBlastConstant_364,axiom,
    ~ b0001010(bitIndex2) ).

fof(bitBlastConstant_363,axiom,
    b0001010(bitIndex1) ).

fof(bitBlastConstant_362,axiom,
    ~ b0001010(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_782,axiom,
    ! [VarCurr] :
      ( v4086(VarCurr)
    <=> ( v4087(VarCurr)
        | v4090(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_228,axiom,
    ! [VarCurr] :
      ( v4090(VarCurr)
    <=> ( ( v4003(VarCurr,bitIndex2)
        <=> $false )
        & ( v4003(VarCurr,bitIndex1)
        <=> $true )
        & ( v4003(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_781,axiom,
    ! [VarCurr] :
      ( v4087(VarCurr)
    <=> ( v4088(VarCurr)
        | v4089(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_227,axiom,
    ! [VarCurr] :
      ( v4089(VarCurr)
    <=> ( ( v4003(VarCurr,bitIndex2)
        <=> $true )
        & ( v4003(VarCurr,bitIndex1)
        <=> $false )
        & ( v4003(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_226,axiom,
    ! [VarCurr] :
      ( v4088(VarCurr)
    <=> ( ( v4003(VarCurr,bitIndex2)
        <=> $false )
        & ( v4003(VarCurr,bitIndex1)
        <=> $false )
        & ( v4003(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_1068,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v4003(VarCurr,B)
      <=> v4005(VarCurr,B) ) ) ).

fof(addAssignment_1067,axiom,
    ! [VarCurr] :
      ( ( v4005(VarCurr,bitIndex2)
      <=> v4007(VarCurr,bitIndex7) )
      & ( v4005(VarCurr,bitIndex1)
      <=> v4007(VarCurr,bitIndex6) )
      & ( v4005(VarCurr,bitIndex0)
      <=> v4007(VarCurr,bitIndex5) ) ) ).

fof(addAssignment_1066,axiom,
    ! [VarCurr,B] :
      ( range_7_5(B)
     => ( v4007(VarCurr,B)
      <=> v4009(VarCurr,B) ) ) ).

fof(addAssignment_1065,axiom,
    ! [VarCurr,B] :
      ( range_7_5(B)
     => ( v4009(VarCurr,B)
      <=> v4047(VarCurr,B) ) ) ).

fof(range_axiom_20,axiom,
    ! [B] :
      ( range_7_5(B)
    <=> ( $false
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B ) ) ).

fof(addCaseBooleanConditionEqualRanges1_66,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4071(VarNext)
       => ! [B] :
            ( range_2_0(B)
           => ( v4049(VarNext,B)
            <=> v4049(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_79,axiom,
    ! [VarNext] :
      ( v4071(VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v4049(VarNext,B)
          <=> v4079(VarNext,B) ) ) ) ).

fof(addAssignment_1064,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v4079(VarNext,B)
          <=> v4077(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_102,axiom,
    ! [VarCurr] :
      ( ~ v4080(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v4077(VarCurr,B)
          <=> v4051(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_104,axiom,
    ! [VarCurr] :
      ( v4080(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v4077(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_323,axiom,
    ! [VarCurr] :
      ( ~ v4080(VarCurr)
    <=> v232(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_780,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4071(VarNext)
      <=> v4072(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_779,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4072(VarNext)
      <=> ( v4073(VarNext)
          & v1278(VarNext) ) ) ) ).

fof(writeUnaryOperator_322,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4073(VarNext)
      <=> v1285(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_101,axiom,
    ! [VarCurr] :
      ( ~ v246(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v4051(VarCurr,B)
          <=> v4049(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_103,axiom,
    ! [VarCurr] :
      ( v246(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v4051(VarCurr,B)
          <=> v4054(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_100,axiom,
    ! [VarCurr] :
      ( ~ v4055(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v4054(VarCurr,B)
          <=> v4056(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_102,axiom,
    ! [VarCurr] :
      ( v4055(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v4054(VarCurr,B)
          <=> $false ) ) ) ).

fof(addAssignment_1063,axiom,
    ! [VarCurr] :
      ( v4056(VarCurr,bitIndex0)
    <=> v4066(VarCurr) ) ).

fof(addAssignment_1062,axiom,
    ! [VarCurr] :
      ( v4056(VarCurr,bitIndex1)
    <=> v4064(VarCurr) ) ).

fof(addAssignment_1061,axiom,
    ! [VarCurr] :
      ( v4056(VarCurr,bitIndex2)
    <=> v4058(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_778,axiom,
    ! [VarCurr] :
      ( v4064(VarCurr)
    <=> ( v4065(VarCurr)
        & v4068(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_109,axiom,
    ! [VarCurr] :
      ( v4068(VarCurr)
    <=> ( v4049(VarCurr,bitIndex0)
        | v4049(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_777,axiom,
    ! [VarCurr] :
      ( v4065(VarCurr)
    <=> ( v4066(VarCurr)
        | v4067(VarCurr) ) ) ).

fof(writeUnaryOperator_321,axiom,
    ! [VarCurr] :
      ( ~ v4067(VarCurr)
    <=> v4049(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_320,axiom,
    ! [VarCurr] :
      ( ~ v4066(VarCurr)
    <=> v4049(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_776,axiom,
    ! [VarCurr] :
      ( v4058(VarCurr)
    <=> ( v4059(VarCurr)
        & v4063(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_108,axiom,
    ! [VarCurr] :
      ( v4063(VarCurr)
    <=> ( v4061(VarCurr)
        | v4049(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_775,axiom,
    ! [VarCurr] :
      ( v4059(VarCurr)
    <=> ( v4060(VarCurr)
        | v4062(VarCurr) ) ) ).

fof(writeUnaryOperator_319,axiom,
    ! [VarCurr] :
      ( ~ v4062(VarCurr)
    <=> v4049(VarCurr,bitIndex2) ) ).

fof(writeUnaryOperator_318,axiom,
    ! [VarCurr] :
      ( ~ v4060(VarCurr)
    <=> v4061(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_107,axiom,
    ! [VarCurr] :
      ( v4061(VarCurr)
    <=> ( v4049(VarCurr,bitIndex0)
        & v4049(VarCurr,bitIndex1) ) ) ).

fof(addBitVectorEqualityBitBlasted_225,axiom,
    ! [VarCurr] :
      ( v4055(VarCurr)
    <=> ( ( v4049(VarCurr,bitIndex2)
        <=> $true )
        & ( v4049(VarCurr,bitIndex1)
        <=> $false )
        & ( v4049(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_361,axiom,
    b101(bitIndex2) ).

fof(bitBlastConstant_360,axiom,
    ~ b101(bitIndex1) ).

fof(bitBlastConstant_359,axiom,
    b101(bitIndex0) ).

fof(memoryReadIntoBuffer_2,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v4049_range_2_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( address(A)
             => ! [B] :
                  ( A = AssociatedAddressVar
                 => ( range_7_0(B)
                   => ( v4047(VarNext,B)
                    <=> v4011_array(VarNext,A,B) ) ) ) ) ) ) ).

fof(memoryConstantWriteDisabled_2,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( $true
              & v4039(VarNext) )
         => ! [B] :
              ( range_7_0(B)
             => ( v4011_array(VarNext,A,B)
              <=> v4011_1__array(VarNext,A,B) ) ) ) ) ).

fof(memoryConstantWriteEnabledInsideRange_2,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( $true
            & v4039(VarNext) )
         => ! [B] :
              ( range_7_0(B)
             => ( v4011_array(VarNext,A,B)
              <=> b00000000(B) ) ) ) ) ).

fof(bitBlastConstant_358,axiom,
    ~ b00000000(bitIndex7) ).

fof(bitBlastConstant_357,axiom,
    ~ b00000000(bitIndex6) ).

fof(bitBlastConstant_356,axiom,
    ~ b00000000(bitIndex5) ).

fof(bitBlastConstant_355,axiom,
    ~ b00000000(bitIndex4) ).

fof(bitBlastConstant_354,axiom,
    ~ b00000000(bitIndex3) ).

fof(bitBlastConstant_353,axiom,
    ~ b00000000(bitIndex2) ).

fof(bitBlastConstant_352,axiom,
    ~ b00000000(bitIndex1) ).

fof(bitBlastConstant_351,axiom,
    ~ b00000000(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_774,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4039(VarNext)
      <=> ( v4040(VarNext)
          & v4045(VarNext) ) ) ) ).

fof(addAssignment_1060,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4045(VarNext)
      <=> v4036(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_773,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4040(VarNext)
      <=> ( v4042(VarNext)
          & v1278(VarNext) ) ) ) ).

fof(writeUnaryOperator_317,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4042(VarNext)
      <=> v1285(VarNext) ) ) ).

fof(memoryWriteDisabled_2,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v4023_range_2_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ~ ( A = AssociatedAddressVar
                  & v4027(VarNext) )
             => ! [B] :
                  ( range_7_0(B)
                 => ( v4011_1__array(VarNext,A,B)
                  <=> v4011_array(VarCurr,A,B) ) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_2,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v4023_range_2_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ( A = AssociatedAddressVar
                & v4027(VarNext) )
             => ! [B] :
                  ( range_7_0(B)
                 => ( v4011_1__array(VarNext,A,B)
                  <=> v4013(VarNext,B) ) ) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_772,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4027(VarNext)
      <=> ( v4028(VarNext)
          & v4034(VarNext) ) ) ) ).

fof(addAssignment_1059,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4034(VarNext)
      <=> v4032(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_771,axiom,
    ! [VarCurr] :
      ( v4032(VarCurr)
    <=> ( v4035(VarCurr)
        & v236(VarCurr) ) ) ).

fof(writeUnaryOperator_316,axiom,
    ! [VarCurr] :
      ( ~ v4035(VarCurr)
    <=> v4036(VarCurr) ) ).

fof(writeUnaryOperator_315,axiom,
    ! [VarCurr] :
      ( ~ v4036(VarCurr)
    <=> v232(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_770,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v4028(VarNext)
      <=> ( v4029(VarNext)
          & v1278(VarNext) ) ) ) ).

fof(writeUnaryOperator_314,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v4029(VarNext)
      <=> v1285(VarNext) ) ) ).

fof(addAssignment_1058,axiom,
    ! [VarCurr,B] :
      ( range_7_0(B)
     => ( v4013(VarCurr,B)
      <=> v4015(VarCurr,B) ) ) ).

fof(addAssignment_1057,axiom,
    ! [VarCurr,B] :
      ( range_7_0(B)
     => ( v4015(VarCurr,B)
      <=> v4017(VarCurr,B) ) ) ).

fof(addAssignment_1056,axiom,
    ! [VarCurr,B] :
      ( range_7_0(B)
     => ( v4017(VarCurr,B)
      <=> v4019(VarCurr,B) ) ) ).

fof(addAssignment_1055,axiom,
    ! [VarCurr,B] :
      ( range_7_0(B)
     => ( v4019(VarCurr,B)
      <=> v4021(VarCurr,B) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_99,axiom,
    ! [VarCurr] :
      ( ~ v3974(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3312(VarCurr,B)
          <=> $false ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_101,axiom,
    ! [VarCurr] :
      ( v3974(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3312(VarCurr,B)
          <=> v3997(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges7,axiom,
    ! [VarCurr] :
      ( ( ~ v3981(VarCurr)
        & ~ v3984(VarCurr)
        & ~ v3987(VarCurr)
        & ~ v3988(VarCurr)
        & ~ v3989(VarCurr)
        & ~ v3992(VarCurr)
        & ~ v3995(VarCurr) )
     => ! [B] :
          ( range_6_0(B)
         => ( v3997(VarCurr,B)
          <=> v3999(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges6,axiom,
    ! [VarCurr] :
      ( v3995(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3997(VarCurr,B)
          <=> b1000010(B) ) ) ) ).

fof(bitBlastConstant_350,axiom,
    b1000010(bitIndex6) ).

fof(bitBlastConstant_349,axiom,
    ~ b1000010(bitIndex5) ).

fof(bitBlastConstant_348,axiom,
    ~ b1000010(bitIndex4) ).

fof(bitBlastConstant_347,axiom,
    ~ b1000010(bitIndex3) ).

fof(bitBlastConstant_346,axiom,
    ~ b1000010(bitIndex2) ).

fof(bitBlastConstant_345,axiom,
    b1000010(bitIndex1) ).

fof(bitBlastConstant_344,axiom,
    ~ b1000010(bitIndex0) ).

fof(addParallelCaseBooleanConditionEqualRanges5,axiom,
    ! [VarCurr] :
      ( v3992(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3997(VarCurr,B)
          <=> b1100000(B) ) ) ) ).

fof(bitBlastConstant_343,axiom,
    b1100000(bitIndex6) ).

fof(bitBlastConstant_342,axiom,
    b1100000(bitIndex5) ).

fof(bitBlastConstant_341,axiom,
    ~ b1100000(bitIndex4) ).

fof(bitBlastConstant_340,axiom,
    ~ b1100000(bitIndex3) ).

fof(bitBlastConstant_339,axiom,
    ~ b1100000(bitIndex2) ).

fof(bitBlastConstant_338,axiom,
    ~ b1100000(bitIndex1) ).

fof(bitBlastConstant_337,axiom,
    ~ b1100000(bitIndex0) ).

fof(addParallelCaseBooleanConditionEqualRanges4,axiom,
    ! [VarCurr] :
      ( v3989(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3997(VarCurr,B)
          <=> b1000000(B) ) ) ) ).

fof(bitBlastConstant_336,axiom,
    b1000000(bitIndex6) ).

fof(bitBlastConstant_335,axiom,
    ~ b1000000(bitIndex5) ).

fof(bitBlastConstant_334,axiom,
    ~ b1000000(bitIndex4) ).

fof(bitBlastConstant_333,axiom,
    ~ b1000000(bitIndex3) ).

fof(bitBlastConstant_332,axiom,
    ~ b1000000(bitIndex2) ).

fof(bitBlastConstant_331,axiom,
    ~ b1000000(bitIndex1) ).

fof(bitBlastConstant_330,axiom,
    ~ b1000000(bitIndex0) ).

fof(addParallelCaseBooleanConditionEqualRanges3_14,axiom,
    ! [VarCurr] :
      ( v3988(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3997(VarCurr,B)
          <=> v3998(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_25,axiom,
    ! [VarCurr] :
      ( v3987(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3997(VarCurr,B)
          <=> b0000010(B) ) ) ) ).

fof(bitBlastConstant_329,axiom,
    ~ b0000010(bitIndex6) ).

fof(bitBlastConstant_328,axiom,
    ~ b0000010(bitIndex5) ).

fof(bitBlastConstant_327,axiom,
    ~ b0000010(bitIndex4) ).

fof(bitBlastConstant_326,axiom,
    ~ b0000010(bitIndex3) ).

fof(bitBlastConstant_325,axiom,
    ~ b0000010(bitIndex2) ).

fof(bitBlastConstant_324,axiom,
    b0000010(bitIndex1) ).

fof(bitBlastConstant_323,axiom,
    ~ b0000010(bitIndex0) ).

fof(addParallelCaseBooleanConditionEqualRanges1_69,axiom,
    ! [VarCurr] :
      ( v3984(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3997(VarCurr,B)
          <=> b0100000(B) ) ) ) ).

fof(bitBlastConstant_322,axiom,
    ~ b0100000(bitIndex6) ).

fof(bitBlastConstant_321,axiom,
    b0100000(bitIndex5) ).

fof(bitBlastConstant_320,axiom,
    ~ b0100000(bitIndex4) ).

fof(bitBlastConstant_319,axiom,
    ~ b0100000(bitIndex3) ).

fof(bitBlastConstant_318,axiom,
    ~ b0100000(bitIndex2) ).

fof(bitBlastConstant_317,axiom,
    ~ b0100000(bitIndex1) ).

fof(bitBlastConstant_316,axiom,
    ~ b0100000(bitIndex0) ).

fof(addParallelCaseBooleanConditionEqualRanges0_69,axiom,
    ! [VarCurr] :
      ( v3981(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3997(VarCurr,B)
          <=> $false ) ) ) ).

fof(bitBlastConstant_315,axiom,
    ~ b0000000(bitIndex6) ).

fof(bitBlastConstant_314,axiom,
    ~ b0000000(bitIndex5) ).

fof(bitBlastConstant_313,axiom,
    ~ b0000000(bitIndex4) ).

fof(bitBlastConstant_312,axiom,
    ~ b0000000(bitIndex3) ).

fof(bitBlastConstant_311,axiom,
    ~ b0000000(bitIndex2) ).

fof(bitBlastConstant_310,axiom,
    ~ b0000000(bitIndex1) ).

fof(bitBlastConstant_309,axiom,
    ~ b0000000(bitIndex0) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_98,axiom,
    ! [VarCurr] :
      ( ~ v3315(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3999(VarCurr,B)
          <=> b1000100(B) ) ) ) ).

fof(bitBlastConstant_308,axiom,
    b1000100(bitIndex6) ).

fof(bitBlastConstant_307,axiom,
    ~ b1000100(bitIndex5) ).

fof(bitBlastConstant_306,axiom,
    ~ b1000100(bitIndex4) ).

fof(bitBlastConstant_305,axiom,
    ~ b1000100(bitIndex3) ).

fof(bitBlastConstant_304,axiom,
    b1000100(bitIndex2) ).

fof(bitBlastConstant_303,axiom,
    ~ b1000100(bitIndex1) ).

fof(bitBlastConstant_302,axiom,
    ~ b1000100(bitIndex0) ).

fof(addConditionBooleanCondEqualRangesThenBranch_100,axiom,
    ! [VarCurr] :
      ( v3315(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3999(VarCurr,B)
          <=> b1000101(B) ) ) ) ).

fof(bitBlastConstant_301,axiom,
    b1000101(bitIndex6) ).

fof(bitBlastConstant_300,axiom,
    ~ b1000101(bitIndex5) ).

fof(bitBlastConstant_299,axiom,
    ~ b1000101(bitIndex4) ).

fof(bitBlastConstant_298,axiom,
    ~ b1000101(bitIndex3) ).

fof(bitBlastConstant_297,axiom,
    b1000101(bitIndex2) ).

fof(bitBlastConstant_296,axiom,
    ~ b1000101(bitIndex1) ).

fof(bitBlastConstant_295,axiom,
    b1000101(bitIndex0) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_97,axiom,
    ! [VarCurr] :
      ( ~ v3315(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3998(VarCurr,B)
          <=> b0000100(B) ) ) ) ).

fof(bitBlastConstant_294,axiom,
    ~ b0000100(bitIndex6) ).

fof(bitBlastConstant_293,axiom,
    ~ b0000100(bitIndex5) ).

fof(bitBlastConstant_292,axiom,
    ~ b0000100(bitIndex4) ).

fof(bitBlastConstant_291,axiom,
    ~ b0000100(bitIndex3) ).

fof(bitBlastConstant_290,axiom,
    b0000100(bitIndex2) ).

fof(bitBlastConstant_289,axiom,
    ~ b0000100(bitIndex1) ).

fof(bitBlastConstant_288,axiom,
    ~ b0000100(bitIndex0) ).

fof(addConditionBooleanCondEqualRangesThenBranch_99,axiom,
    ! [VarCurr] :
      ( v3315(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3998(VarCurr,B)
          <=> b0000101(B) ) ) ) ).

fof(bitBlastConstant_287,axiom,
    ~ b0000101(bitIndex6) ).

fof(bitBlastConstant_286,axiom,
    ~ b0000101(bitIndex5) ).

fof(bitBlastConstant_285,axiom,
    ~ b0000101(bitIndex4) ).

fof(bitBlastConstant_284,axiom,
    ~ b0000101(bitIndex3) ).

fof(bitBlastConstant_283,axiom,
    b0000101(bitIndex2) ).

fof(bitBlastConstant_282,axiom,
    ~ b0000101(bitIndex1) ).

fof(bitBlastConstant_281,axiom,
    b0000101(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_769,axiom,
    ! [VarCurr] :
      ( v3974(VarCurr)
    <=> ( v3975(VarCurr)
        | v3996(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_224,axiom,
    ! [VarCurr] :
      ( v3996(VarCurr)
    <=> ( ( v522(VarCurr,bitIndex3)
        <=> $false )
        & ( v522(VarCurr,bitIndex2)
        <=> $true )
        & ( v522(VarCurr,bitIndex1)
        <=> $true )
        & ( v522(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_768,axiom,
    ! [VarCurr] :
      ( v3975(VarCurr)
    <=> ( v3976(VarCurr)
        | v3995(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_223,axiom,
    ! [VarCurr] :
      ( v3995(VarCurr)
    <=> ( ( v522(VarCurr,bitIndex3)
        <=> $false )
        & ( v522(VarCurr,bitIndex2)
        <=> $true )
        & ( v522(VarCurr,bitIndex1)
        <=> $true )
        & ( v522(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_767,axiom,
    ! [VarCurr] :
      ( v3976(VarCurr)
    <=> ( v3977(VarCurr)
        | v3992(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_766,axiom,
    ! [VarCurr] :
      ( v3992(VarCurr)
    <=> ( v3993(VarCurr)
        | v3994(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_222,axiom,
    ! [VarCurr] :
      ( v3994(VarCurr)
    <=> ( ( v522(VarCurr,bitIndex3)
        <=> $false )
        & ( v522(VarCurr,bitIndex2)
        <=> $true )
        & ( v522(VarCurr,bitIndex1)
        <=> $false )
        & ( v522(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_221,axiom,
    ! [VarCurr] :
      ( v3993(VarCurr)
    <=> ( ( v522(VarCurr,bitIndex3)
        <=> $false )
        & ( v522(VarCurr,bitIndex2)
        <=> $false )
        & ( v522(VarCurr,bitIndex1)
        <=> $false )
        & ( v522(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_765,axiom,
    ! [VarCurr] :
      ( v3977(VarCurr)
    <=> ( v3978(VarCurr)
        | v3989(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_764,axiom,
    ! [VarCurr] :
      ( v3989(VarCurr)
    <=> ( v3990(VarCurr)
        | v3991(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_220,axiom,
    ! [VarCurr] :
      ( v3991(VarCurr)
    <=> ( ( v522(VarCurr,bitIndex3)
        <=> $false )
        & ( v522(VarCurr,bitIndex2)
        <=> $true )
        & ( v522(VarCurr,bitIndex1)
        <=> $false )
        & ( v522(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_219,axiom,
    ! [VarCurr] :
      ( v3990(VarCurr)
    <=> ( ( v522(VarCurr,bitIndex3)
        <=> $false )
        & ( v522(VarCurr,bitIndex2)
        <=> $false )
        & ( v522(VarCurr,bitIndex1)
        <=> $false )
        & ( v522(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_763,axiom,
    ! [VarCurr] :
      ( v3978(VarCurr)
    <=> ( v3979(VarCurr)
        | v3988(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_218,axiom,
    ! [VarCurr] :
      ( v3988(VarCurr)
    <=> ( ( v522(VarCurr,bitIndex3)
        <=> $true )
        & ( v522(VarCurr,bitIndex2)
        <=> $true )
        & ( v522(VarCurr,bitIndex1)
        <=> $true )
        & ( v522(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_762,axiom,
    ! [VarCurr] :
      ( v3979(VarCurr)
    <=> ( v3980(VarCurr)
        | v3987(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_217,axiom,
    ! [VarCurr] :
      ( v3987(VarCurr)
    <=> ( ( v522(VarCurr,bitIndex3)
        <=> $true )
        & ( v522(VarCurr,bitIndex2)
        <=> $true )
        & ( v522(VarCurr,bitIndex1)
        <=> $true )
        & ( v522(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_761,axiom,
    ! [VarCurr] :
      ( v3980(VarCurr)
    <=> ( v3981(VarCurr)
        | v3984(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_760,axiom,
    ! [VarCurr] :
      ( v3984(VarCurr)
    <=> ( v3985(VarCurr)
        | v3986(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_216,axiom,
    ! [VarCurr] :
      ( v3986(VarCurr)
    <=> ( ( v522(VarCurr,bitIndex3)
        <=> $true )
        & ( v522(VarCurr,bitIndex2)
        <=> $true )
        & ( v522(VarCurr,bitIndex1)
        <=> $false )
        & ( v522(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_215,axiom,
    ! [VarCurr] :
      ( v3985(VarCurr)
    <=> ( ( v522(VarCurr,bitIndex3)
        <=> $true )
        & ( v522(VarCurr,bitIndex2)
        <=> $false )
        & ( v522(VarCurr,bitIndex1)
        <=> $false )
        & ( v522(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_759,axiom,
    ! [VarCurr] :
      ( v3981(VarCurr)
    <=> ( v3982(VarCurr)
        | v3983(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_214,axiom,
    ! [VarCurr] :
      ( v3983(VarCurr)
    <=> ( ( v522(VarCurr,bitIndex3)
        <=> $true )
        & ( v522(VarCurr,bitIndex2)
        <=> $true )
        & ( v522(VarCurr,bitIndex1)
        <=> $false )
        & ( v522(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_213,axiom,
    ! [VarCurr] :
      ( v3982(VarCurr)
    <=> ( ( v522(VarCurr,bitIndex3)
        <=> $true )
        & ( v522(VarCurr,bitIndex2)
        <=> $false )
        & ( v522(VarCurr,bitIndex1)
        <=> $false )
        & ( v522(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_96,axiom,
    ! [VarCurr] :
      ( ~ v3965(VarCurr)
     => ( v3315(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_98,axiom,
    ! [VarCurr] :
      ( v3965(VarCurr)
     => ( v3315(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_212,axiom,
    ! [VarCurr] :
      ( v3965(VarCurr)
    <=> ( ( v3317(VarCurr,bitIndex7)
        <=> v3961(VarCurr,bitIndex27) )
        & ( v3317(VarCurr,bitIndex6)
        <=> v3961(VarCurr,bitIndex26) )
        & ( v3317(VarCurr,bitIndex5)
        <=> v3961(VarCurr,bitIndex25) )
        & ( v3317(VarCurr,bitIndex4)
        <=> v3961(VarCurr,bitIndex24) )
        & ( v3317(VarCurr,bitIndex3)
        <=> v3961(VarCurr,bitIndex23) )
        & ( v3317(VarCurr,bitIndex2)
        <=> v3961(VarCurr,bitIndex22) )
        & ( v3317(VarCurr,bitIndex1)
        <=> v3961(VarCurr,bitIndex21) )
        & ( v3317(VarCurr,bitIndex0)
        <=> v3961(VarCurr,bitIndex20) ) ) ) ).

fof(addAssignment_1054,axiom,
    ! [VarCurr,B] :
      ( range_27_20(B)
     => ( v3961(VarCurr,B)
      <=> v3963(VarCurr,B) ) ) ).

fof(range_axiom_19,axiom,
    ! [B] :
      ( range_27_20(B)
    <=> ( $false
        | bitIndex20 = B
        | bitIndex21 = B
        | bitIndex22 = B
        | bitIndex23 = B
        | bitIndex24 = B
        | bitIndex25 = B
        | bitIndex26 = B
        | bitIndex27 = B ) ) ).

fof(addAssignment_1053,axiom,
    ! [VarCurr] :
      ( ( v3963(VarCurr,bitIndex27)
      <=> v526(VarCurr,bitIndex54) )
      & ( v3963(VarCurr,bitIndex26)
      <=> v526(VarCurr,bitIndex53) )
      & ( v3963(VarCurr,bitIndex25)
      <=> v526(VarCurr,bitIndex52) )
      & ( v3963(VarCurr,bitIndex24)
      <=> v526(VarCurr,bitIndex51) )
      & ( v3963(VarCurr,bitIndex23)
      <=> v526(VarCurr,bitIndex50) )
      & ( v3963(VarCurr,bitIndex22)
      <=> v526(VarCurr,bitIndex49) )
      & ( v3963(VarCurr,bitIndex21)
      <=> v526(VarCurr,bitIndex48) )
      & ( v3963(VarCurr,bitIndex20)
      <=> v526(VarCurr,bitIndex47) ) ) ).

fof(addAssignment_1052,axiom,
    ! [VarCurr,B] :
      ( range_54_47(B)
     => ( v526(VarCurr,B)
      <=> v528(VarCurr,B) ) ) ).

fof(addAssignment_1051,axiom,
    ! [VarCurr,B] :
      ( range_54_47(B)
     => ( v528(VarCurr,B)
      <=> v598(VarCurr,B) ) ) ).

fof(range_axiom_18,axiom,
    ! [B] :
      ( range_54_47(B)
    <=> ( $false
        | bitIndex47 = B
        | bitIndex48 = B
        | bitIndex49 = B
        | bitIndex50 = B
        | bitIndex51 = B
        | bitIndex52 = B
        | bitIndex53 = B
        | bitIndex54 = B ) ) ).

fof(addAssignment_1050,axiom,
    ! [VarCurr,B] :
      ( range_7_0(B)
     => ( v3317(VarCurr,B)
      <=> v3319(VarCurr,B) ) ) ).

fof(addAssignment_1049,axiom,
    ! [VarCurr,B] :
      ( range_7_0(B)
     => ( v3319(VarCurr,B)
      <=> v3321(VarCurr,B) ) ) ).

fof(addAssignment_1048,axiom,
    ! [VarCurr,B] :
      ( range_7_0(B)
     => ( v3321(VarCurr,B)
      <=> v3323(VarCurr,B) ) ) ).

fof(addAssignment_1047,axiom,
    ! [VarCurr,B] :
      ( range_7_0(B)
     => ( v3323(VarCurr,B)
      <=> v3325(VarCurr,B) ) ) ).

fof(addAssignment_1046,axiom,
    ! [VarCurr,B] :
      ( range_7_0(B)
     => ( v3325(VarCurr,B)
      <=> v3327(VarCurr,B) ) ) ).

fof(addAssignment_1045,axiom,
    ! [VarCurr,B] :
      ( range_7_0(B)
     => ( v3327(VarCurr,B)
      <=> v3329(VarCurr,B) ) ) ).

fof(addAssignment_1044,axiom,
    ! [VarCurr,B] :
      ( range_7_0(B)
     => ( v3329(VarCurr,B)
      <=> v3331(VarCurr,B) ) ) ).

fof(range_axiom_17,axiom,
    ! [B] :
      ( range_7_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B ) ) ).

fof(addAssignment_1043,axiom,
    ! [VarCurr] :
      ( ( v3331(VarCurr,bitIndex7)
      <=> v3333(VarCurr,bitIndex31) )
      & ( v3331(VarCurr,bitIndex6)
      <=> v3333(VarCurr,bitIndex30) )
      & ( v3331(VarCurr,bitIndex5)
      <=> v3333(VarCurr,bitIndex29) )
      & ( v3331(VarCurr,bitIndex4)
      <=> v3333(VarCurr,bitIndex28) )
      & ( v3331(VarCurr,bitIndex3)
      <=> v3333(VarCurr,bitIndex27) )
      & ( v3331(VarCurr,bitIndex2)
      <=> v3333(VarCurr,bitIndex26) )
      & ( v3331(VarCurr,bitIndex1)
      <=> v3333(VarCurr,bitIndex25) )
      & ( v3331(VarCurr,bitIndex0)
      <=> v3333(VarCurr,bitIndex24) ) ) ).

fof(addAssignment_1042,axiom,
    ! [VarCurr,B] :
      ( range_31_24(B)
     => ( v3333(VarCurr,B)
      <=> v3335(VarCurr,B) ) ) ).

fof(range_axiom_16,axiom,
    ! [B] :
      ( range_31_24(B)
    <=> ( $false
        | bitIndex24 = B
        | bitIndex25 = B
        | bitIndex26 = B
        | bitIndex27 = B
        | bitIndex28 = B
        | bitIndex29 = B
        | bitIndex30 = B
        | bitIndex31 = B ) ) ).

fof(addAssignment_1041,axiom,
    ! [VarCurr] :
      ( v3335(VarCurr,bitIndex31)
    <=> v3893(VarCurr) ) ).

fof(addAssignment_1040,axiom,
    ! [VarCurr] :
      ( v3335(VarCurr,bitIndex30)
    <=> v3825(VarCurr) ) ).

fof(addAssignment_1039,axiom,
    ! [VarCurr] :
      ( v3335(VarCurr,bitIndex29)
    <=> v3757(VarCurr) ) ).

fof(addAssignment_1038,axiom,
    ! [VarCurr] :
      ( v3335(VarCurr,bitIndex28)
    <=> v3689(VarCurr) ) ).

fof(addAssignment_1037,axiom,
    ! [VarCurr] :
      ( v3335(VarCurr,bitIndex27)
    <=> v3621(VarCurr) ) ).

fof(addAssignment_1036,axiom,
    ! [VarCurr] :
      ( v3335(VarCurr,bitIndex26)
    <=> v3553(VarCurr) ) ).

fof(addAssignment_1035,axiom,
    ! [VarCurr] :
      ( v3335(VarCurr,bitIndex25)
    <=> v3485(VarCurr) ) ).

fof(addAssignment_1034,axiom,
    ! [VarCurr] :
      ( v3335(VarCurr,bitIndex24)
    <=> v3337(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_65,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3916(VarNext)
       => ( v3893(VarNext)
        <=> v3893(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_78,axiom,
    ! [VarNext] :
      ( v3916(VarNext)
     => ( v3893(VarNext)
      <=> v3951(VarNext) ) ) ).

fof(addAssignment_1033,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3951(VarNext)
      <=> v3949(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_68,axiom,
    ! [VarCurr] :
      ( ~ v3895(VarCurr)
     => ( v3949(VarCurr)
      <=> v3952(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_68,axiom,
    ! [VarCurr] :
      ( v3895(VarCurr)
     => ( v3949(VarCurr)
      <=> v3897(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_67,axiom,
    ! [VarCurr] :
      ( ~ v3929(VarCurr)
     => ( v3952(VarCurr)
      <=> v3911(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_67,axiom,
    ! [VarCurr] :
      ( v3929(VarCurr)
     => ( v3952(VarCurr)
      <=> v3953(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_24,axiom,
    ! [VarCurr] :
      ( ( ~ v3932(VarCurr)
        & ~ v3934(VarCurr) )
     => ( v3953(VarCurr)
      <=> v3957(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_66,axiom,
    ! [VarCurr] :
      ( v3934(VarCurr)
     => ( v3953(VarCurr)
      <=> v3956(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_66,axiom,
    ! [VarCurr] :
      ( v3932(VarCurr)
     => ( v3953(VarCurr)
      <=> v3954(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_65,axiom,
    ! [VarCurr] :
      ( ~ v3942(VarCurr)
     => ( v3957(VarCurr)
      <=> v3911(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_65,axiom,
    ! [VarCurr] :
      ( v3942(VarCurr)
     => ( v3957(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_64,axiom,
    ! [VarCurr] :
      ( ~ v3936(VarCurr)
     => ( v3956(VarCurr)
      <=> v3911(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_64,axiom,
    ! [VarCurr] :
      ( v3936(VarCurr)
     => ( v3956(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_95,axiom,
    ! [VarCurr] :
      ( ~ v3955(VarCurr)
     => ( v3954(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_97,axiom,
    ! [VarCurr] :
      ( v3955(VarCurr)
     => ( v3954(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_211,axiom,
    ! [VarCurr] :
      ( v3955(VarCurr)
    <=> ( v3905(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_758,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3916(VarNext)
      <=> ( v3917(VarNext)
          & v3926(VarNext) ) ) ) ).

fof(addAssignment_1032,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3926(VarNext)
      <=> v3924(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_757,axiom,
    ! [VarCurr] :
      ( v3924(VarCurr)
    <=> ( v3895(VarCurr)
        | v3927(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_756,axiom,
    ! [VarCurr] :
      ( v3927(VarCurr)
    <=> ( v3928(VarCurr)
        & v3948(VarCurr) ) ) ).

fof(writeUnaryOperator_313,axiom,
    ! [VarCurr] :
      ( ~ v3948(VarCurr)
    <=> v3895(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_755,axiom,
    ! [VarCurr] :
      ( v3928(VarCurr)
    <=> ( v3929(VarCurr)
        | v3946(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_754,axiom,
    ! [VarCurr] :
      ( v3946(VarCurr)
    <=> ( v3907(VarCurr)
        & v3947(VarCurr) ) ) ).

fof(writeUnaryOperator_312,axiom,
    ! [VarCurr] :
      ( ~ v3947(VarCurr)
    <=> v3909(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_753,axiom,
    ! [VarCurr] :
      ( v3929(VarCurr)
    <=> ( v3930(VarCurr)
        & v3909(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_752,axiom,
    ! [VarCurr] :
      ( v3930(VarCurr)
    <=> ( v3931(VarCurr)
        | v3940(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_751,axiom,
    ! [VarCurr] :
      ( v3940(VarCurr)
    <=> ( v3941(VarCurr)
        & v3945(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_210,axiom,
    ! [VarCurr] :
      ( v3945(VarCurr)
    <=> ( ( v3933(VarCurr,bitIndex2)
        <=> $false )
        & ( v3933(VarCurr,bitIndex1)
        <=> $false )
        & ( v3933(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_750,axiom,
    ! [VarCurr] :
      ( v3941(VarCurr)
    <=> ( v3942(VarCurr)
        | v3943(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_749,axiom,
    ! [VarCurr] :
      ( v3943(VarCurr)
    <=> ( v3907(VarCurr)
        & v3944(VarCurr) ) ) ).

fof(writeUnaryOperator_311,axiom,
    ! [VarCurr] :
      ( ~ v3944(VarCurr)
    <=> v3942(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_209,axiom,
    ! [VarCurr] :
      ( v3942(VarCurr)
    <=> ( v3905(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_748,axiom,
    ! [VarCurr] :
      ( v3931(VarCurr)
    <=> ( v3932(VarCurr)
        | v3934(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_747,axiom,
    ! [VarCurr] :
      ( v3934(VarCurr)
    <=> ( v3935(VarCurr)
        & v3939(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_208,axiom,
    ! [VarCurr] :
      ( v3939(VarCurr)
    <=> ( ( v3933(VarCurr,bitIndex2)
        <=> $false )
        & ( v3933(VarCurr,bitIndex1)
        <=> $true )
        & ( v3933(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_746,axiom,
    ! [VarCurr] :
      ( v3935(VarCurr)
    <=> ( v3936(VarCurr)
        | v3937(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_745,axiom,
    ! [VarCurr] :
      ( v3937(VarCurr)
    <=> ( v3907(VarCurr)
        & v3938(VarCurr) ) ) ).

fof(writeUnaryOperator_310,axiom,
    ! [VarCurr] :
      ( ~ v3938(VarCurr)
    <=> v3936(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_207,axiom,
    ! [VarCurr] :
      ( v3936(VarCurr)
    <=> ( v3905(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_206,axiom,
    ! [VarCurr] :
      ( v3932(VarCurr)
    <=> ( ( v3933(VarCurr,bitIndex2)
        <=> $true )
        & ( v3933(VarCurr,bitIndex1)
        <=> $false )
        & ( v3933(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1031,axiom,
    ! [VarCurr] :
      ( v3933(VarCurr,bitIndex0)
    <=> v3903(VarCurr) ) ).

fof(addAssignment_1030,axiom,
    ! [VarCurr] :
      ( v3933(VarCurr,bitIndex1)
    <=> v3901(VarCurr) ) ).

fof(addAssignment_1029,axiom,
    ! [VarCurr] :
      ( v3933(VarCurr,bitIndex2)
    <=> v3899(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_744,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3917(VarNext)
      <=> ( v3918(VarNext)
          & v3913(VarNext) ) ) ) ).

fof(writeUnaryOperator_309,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3918(VarNext)
      <=> v3920(VarNext) ) ) ).

fof(addAssignment_1028,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3920(VarNext)
      <=> v3913(VarCurr) ) ) ).

fof(addAssignment_1027,axiom,
    ! [VarCurr] :
      ( v3913(VarCurr)
    <=> v3429(VarCurr) ) ).

fof(addAssignment_1026,axiom,
    ! [VarCurr] :
      ( v3911(VarCurr)
    <=> $false ) ).

fof(addAssignment_1025,axiom,
    ! [VarCurr] :
      ( v3909(VarCurr)
    <=> v3392(VarCurr) ) ).

fof(addAssignment_1024,axiom,
    ! [VarCurr] :
      ( v3907(VarCurr)
    <=> $false ) ).

fof(addAssignment_1023,axiom,
    ! [VarCurr] :
      ( v3905(VarCurr)
    <=> v3370(VarCurr,bitIndex31) ) ).

fof(addAssignment_1022,axiom,
    ! [VarCurr] :
      ( v3370(VarCurr,bitIndex31)
    <=> v3372(VarCurr,bitIndex31) ) ).

fof(addAssignment_1021,axiom,
    ! [VarCurr] :
      ( v3372(VarCurr,bitIndex31)
    <=> v3374(VarCurr,bitIndex31) ) ).

fof(addAssignment_1020,axiom,
    ! [VarCurr] :
      ( v3374(VarCurr,bitIndex31)
    <=> v3376(VarCurr,bitIndex31) ) ).

fof(addAssignment_1019,axiom,
    ! [VarCurr] :
      ( v3376(VarCurr,bitIndex31)
    <=> v3378(VarCurr,bitIndex31) ) ).

fof(addAssignment_1018,axiom,
    ! [VarCurr] :
      ( v3378(VarCurr,bitIndex31)
    <=> v3380(VarCurr,bitIndex31) ) ).

fof(addAssignment_1017,axiom,
    ! [VarCurr] :
      ( v3380(VarCurr,bitIndex31)
    <=> v3382(VarCurr,bitIndex31) ) ).

fof(addAssignment_1016,axiom,
    ! [VarCurr] :
      ( v3382(VarCurr,bitIndex31)
    <=> v3384(VarCurr,bitIndex31) ) ).

fof(addAssignment_1015,axiom,
    ! [VarCurr] :
      ( v3384(VarCurr,bitIndex31)
    <=> v3386(VarCurr,bitIndex31) ) ).

fof(addAssignment_1014,axiom,
    ! [VarCurr] :
      ( v3903(VarCurr)
    <=> $false ) ).

fof(addAssignment_1013,axiom,
    ! [VarCurr] :
      ( v3901(VarCurr)
    <=> $false ) ).

fof(addAssignment_1012,axiom,
    ! [VarCurr] :
      ( v3899(VarCurr)
    <=> $true ) ).

fof(addAssignment_1011,axiom,
    ! [VarCurr] :
      ( v3897(VarCurr)
    <=> $false ) ).

fof(addAssignment_1010,axiom,
    ! [VarCurr] :
      ( v3895(VarCurr)
    <=> v3341(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_64,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3848(VarNext)
       => ( v3825(VarNext)
        <=> v3825(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_77,axiom,
    ! [VarNext] :
      ( v3848(VarNext)
     => ( v3825(VarNext)
      <=> v3883(VarNext) ) ) ).

fof(addAssignment_1009,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3883(VarNext)
      <=> v3881(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_63,axiom,
    ! [VarCurr] :
      ( ~ v3827(VarCurr)
     => ( v3881(VarCurr)
      <=> v3884(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_63,axiom,
    ! [VarCurr] :
      ( v3827(VarCurr)
     => ( v3881(VarCurr)
      <=> v3829(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_62,axiom,
    ! [VarCurr] :
      ( ~ v3861(VarCurr)
     => ( v3884(VarCurr)
      <=> v3843(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_62,axiom,
    ! [VarCurr] :
      ( v3861(VarCurr)
     => ( v3884(VarCurr)
      <=> v3885(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_23,axiom,
    ! [VarCurr] :
      ( ( ~ v3864(VarCurr)
        & ~ v3866(VarCurr) )
     => ( v3885(VarCurr)
      <=> v3889(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_61,axiom,
    ! [VarCurr] :
      ( v3866(VarCurr)
     => ( v3885(VarCurr)
      <=> v3888(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_61,axiom,
    ! [VarCurr] :
      ( v3864(VarCurr)
     => ( v3885(VarCurr)
      <=> v3886(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_60,axiom,
    ! [VarCurr] :
      ( ~ v3874(VarCurr)
     => ( v3889(VarCurr)
      <=> v3843(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_60,axiom,
    ! [VarCurr] :
      ( v3874(VarCurr)
     => ( v3889(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_59,axiom,
    ! [VarCurr] :
      ( ~ v3868(VarCurr)
     => ( v3888(VarCurr)
      <=> v3843(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_59,axiom,
    ! [VarCurr] :
      ( v3868(VarCurr)
     => ( v3888(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_94,axiom,
    ! [VarCurr] :
      ( ~ v3887(VarCurr)
     => ( v3886(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_96,axiom,
    ! [VarCurr] :
      ( v3887(VarCurr)
     => ( v3886(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_205,axiom,
    ! [VarCurr] :
      ( v3887(VarCurr)
    <=> ( v3837(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_743,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3848(VarNext)
      <=> ( v3849(VarNext)
          & v3858(VarNext) ) ) ) ).

fof(addAssignment_1008,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3858(VarNext)
      <=> v3856(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_742,axiom,
    ! [VarCurr] :
      ( v3856(VarCurr)
    <=> ( v3827(VarCurr)
        | v3859(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_741,axiom,
    ! [VarCurr] :
      ( v3859(VarCurr)
    <=> ( v3860(VarCurr)
        & v3880(VarCurr) ) ) ).

fof(writeUnaryOperator_308,axiom,
    ! [VarCurr] :
      ( ~ v3880(VarCurr)
    <=> v3827(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_740,axiom,
    ! [VarCurr] :
      ( v3860(VarCurr)
    <=> ( v3861(VarCurr)
        | v3878(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_739,axiom,
    ! [VarCurr] :
      ( v3878(VarCurr)
    <=> ( v3839(VarCurr)
        & v3879(VarCurr) ) ) ).

fof(writeUnaryOperator_307,axiom,
    ! [VarCurr] :
      ( ~ v3879(VarCurr)
    <=> v3841(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_738,axiom,
    ! [VarCurr] :
      ( v3861(VarCurr)
    <=> ( v3862(VarCurr)
        & v3841(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_737,axiom,
    ! [VarCurr] :
      ( v3862(VarCurr)
    <=> ( v3863(VarCurr)
        | v3872(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_736,axiom,
    ! [VarCurr] :
      ( v3872(VarCurr)
    <=> ( v3873(VarCurr)
        & v3877(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_204,axiom,
    ! [VarCurr] :
      ( v3877(VarCurr)
    <=> ( ( v3865(VarCurr,bitIndex2)
        <=> $false )
        & ( v3865(VarCurr,bitIndex1)
        <=> $false )
        & ( v3865(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_735,axiom,
    ! [VarCurr] :
      ( v3873(VarCurr)
    <=> ( v3874(VarCurr)
        | v3875(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_734,axiom,
    ! [VarCurr] :
      ( v3875(VarCurr)
    <=> ( v3839(VarCurr)
        & v3876(VarCurr) ) ) ).

fof(writeUnaryOperator_306,axiom,
    ! [VarCurr] :
      ( ~ v3876(VarCurr)
    <=> v3874(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_203,axiom,
    ! [VarCurr] :
      ( v3874(VarCurr)
    <=> ( v3837(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_733,axiom,
    ! [VarCurr] :
      ( v3863(VarCurr)
    <=> ( v3864(VarCurr)
        | v3866(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_732,axiom,
    ! [VarCurr] :
      ( v3866(VarCurr)
    <=> ( v3867(VarCurr)
        & v3871(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_202,axiom,
    ! [VarCurr] :
      ( v3871(VarCurr)
    <=> ( ( v3865(VarCurr,bitIndex2)
        <=> $false )
        & ( v3865(VarCurr,bitIndex1)
        <=> $true )
        & ( v3865(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_731,axiom,
    ! [VarCurr] :
      ( v3867(VarCurr)
    <=> ( v3868(VarCurr)
        | v3869(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_730,axiom,
    ! [VarCurr] :
      ( v3869(VarCurr)
    <=> ( v3839(VarCurr)
        & v3870(VarCurr) ) ) ).

fof(writeUnaryOperator_305,axiom,
    ! [VarCurr] :
      ( ~ v3870(VarCurr)
    <=> v3868(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_201,axiom,
    ! [VarCurr] :
      ( v3868(VarCurr)
    <=> ( v3837(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_200,axiom,
    ! [VarCurr] :
      ( v3864(VarCurr)
    <=> ( ( v3865(VarCurr,bitIndex2)
        <=> $true )
        & ( v3865(VarCurr,bitIndex1)
        <=> $false )
        & ( v3865(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_1007,axiom,
    ! [VarCurr] :
      ( v3865(VarCurr,bitIndex0)
    <=> v3835(VarCurr) ) ).

fof(addAssignment_1006,axiom,
    ! [VarCurr] :
      ( v3865(VarCurr,bitIndex1)
    <=> v3833(VarCurr) ) ).

fof(addAssignment_1005,axiom,
    ! [VarCurr] :
      ( v3865(VarCurr,bitIndex2)
    <=> v3831(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_729,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3849(VarNext)
      <=> ( v3850(VarNext)
          & v3845(VarNext) ) ) ) ).

fof(writeUnaryOperator_304,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3850(VarNext)
      <=> v3852(VarNext) ) ) ).

fof(addAssignment_1004,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3852(VarNext)
      <=> v3845(VarCurr) ) ) ).

fof(addAssignment_1003,axiom,
    ! [VarCurr] :
      ( v3845(VarCurr)
    <=> v3429(VarCurr) ) ).

fof(addAssignment_1002,axiom,
    ! [VarCurr] :
      ( v3843(VarCurr)
    <=> $false ) ).

fof(addAssignment_1001,axiom,
    ! [VarCurr] :
      ( v3841(VarCurr)
    <=> v3392(VarCurr) ) ).

fof(addAssignment_1000,axiom,
    ! [VarCurr] :
      ( v3839(VarCurr)
    <=> $false ) ).

fof(addAssignment_999,axiom,
    ! [VarCurr] :
      ( v3837(VarCurr)
    <=> v3370(VarCurr,bitIndex30) ) ).

fof(addAssignment_998,axiom,
    ! [VarCurr] :
      ( v3370(VarCurr,bitIndex30)
    <=> v3372(VarCurr,bitIndex30) ) ).

fof(addAssignment_997,axiom,
    ! [VarCurr] :
      ( v3372(VarCurr,bitIndex30)
    <=> v3374(VarCurr,bitIndex30) ) ).

fof(addAssignment_996,axiom,
    ! [VarCurr] :
      ( v3374(VarCurr,bitIndex30)
    <=> v3376(VarCurr,bitIndex30) ) ).

fof(addAssignment_995,axiom,
    ! [VarCurr] :
      ( v3376(VarCurr,bitIndex30)
    <=> v3378(VarCurr,bitIndex30) ) ).

fof(addAssignment_994,axiom,
    ! [VarCurr] :
      ( v3378(VarCurr,bitIndex30)
    <=> v3380(VarCurr,bitIndex30) ) ).

fof(addAssignment_993,axiom,
    ! [VarCurr] :
      ( v3380(VarCurr,bitIndex30)
    <=> v3382(VarCurr,bitIndex30) ) ).

fof(addAssignment_992,axiom,
    ! [VarCurr] :
      ( v3382(VarCurr,bitIndex30)
    <=> v3384(VarCurr,bitIndex30) ) ).

fof(addAssignment_991,axiom,
    ! [VarCurr] :
      ( v3384(VarCurr,bitIndex30)
    <=> v3386(VarCurr,bitIndex30) ) ).

fof(addAssignment_990,axiom,
    ! [VarCurr] :
      ( v3835(VarCurr)
    <=> $false ) ).

fof(addAssignment_989,axiom,
    ! [VarCurr] :
      ( v3833(VarCurr)
    <=> $false ) ).

fof(addAssignment_988,axiom,
    ! [VarCurr] :
      ( v3831(VarCurr)
    <=> $true ) ).

fof(addAssignment_987,axiom,
    ! [VarCurr] :
      ( v3829(VarCurr)
    <=> $false ) ).

fof(addAssignment_986,axiom,
    ! [VarCurr] :
      ( v3827(VarCurr)
    <=> v3341(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_63,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3780(VarNext)
       => ( v3757(VarNext)
        <=> v3757(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_76,axiom,
    ! [VarNext] :
      ( v3780(VarNext)
     => ( v3757(VarNext)
      <=> v3815(VarNext) ) ) ).

fof(addAssignment_985,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3815(VarNext)
      <=> v3813(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_58,axiom,
    ! [VarCurr] :
      ( ~ v3759(VarCurr)
     => ( v3813(VarCurr)
      <=> v3816(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_58,axiom,
    ! [VarCurr] :
      ( v3759(VarCurr)
     => ( v3813(VarCurr)
      <=> v3761(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_57,axiom,
    ! [VarCurr] :
      ( ~ v3793(VarCurr)
     => ( v3816(VarCurr)
      <=> v3775(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_57,axiom,
    ! [VarCurr] :
      ( v3793(VarCurr)
     => ( v3816(VarCurr)
      <=> v3817(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_22,axiom,
    ! [VarCurr] :
      ( ( ~ v3796(VarCurr)
        & ~ v3798(VarCurr) )
     => ( v3817(VarCurr)
      <=> v3821(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_56,axiom,
    ! [VarCurr] :
      ( v3798(VarCurr)
     => ( v3817(VarCurr)
      <=> v3820(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_56,axiom,
    ! [VarCurr] :
      ( v3796(VarCurr)
     => ( v3817(VarCurr)
      <=> v3818(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_55,axiom,
    ! [VarCurr] :
      ( ~ v3806(VarCurr)
     => ( v3821(VarCurr)
      <=> v3775(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_55,axiom,
    ! [VarCurr] :
      ( v3806(VarCurr)
     => ( v3821(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_54,axiom,
    ! [VarCurr] :
      ( ~ v3800(VarCurr)
     => ( v3820(VarCurr)
      <=> v3775(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_54,axiom,
    ! [VarCurr] :
      ( v3800(VarCurr)
     => ( v3820(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_93,axiom,
    ! [VarCurr] :
      ( ~ v3819(VarCurr)
     => ( v3818(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_95,axiom,
    ! [VarCurr] :
      ( v3819(VarCurr)
     => ( v3818(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_199,axiom,
    ! [VarCurr] :
      ( v3819(VarCurr)
    <=> ( v3769(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_728,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3780(VarNext)
      <=> ( v3781(VarNext)
          & v3790(VarNext) ) ) ) ).

fof(addAssignment_984,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3790(VarNext)
      <=> v3788(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_727,axiom,
    ! [VarCurr] :
      ( v3788(VarCurr)
    <=> ( v3759(VarCurr)
        | v3791(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_726,axiom,
    ! [VarCurr] :
      ( v3791(VarCurr)
    <=> ( v3792(VarCurr)
        & v3812(VarCurr) ) ) ).

fof(writeUnaryOperator_303,axiom,
    ! [VarCurr] :
      ( ~ v3812(VarCurr)
    <=> v3759(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_725,axiom,
    ! [VarCurr] :
      ( v3792(VarCurr)
    <=> ( v3793(VarCurr)
        | v3810(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_724,axiom,
    ! [VarCurr] :
      ( v3810(VarCurr)
    <=> ( v3771(VarCurr)
        & v3811(VarCurr) ) ) ).

fof(writeUnaryOperator_302,axiom,
    ! [VarCurr] :
      ( ~ v3811(VarCurr)
    <=> v3773(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_723,axiom,
    ! [VarCurr] :
      ( v3793(VarCurr)
    <=> ( v3794(VarCurr)
        & v3773(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_722,axiom,
    ! [VarCurr] :
      ( v3794(VarCurr)
    <=> ( v3795(VarCurr)
        | v3804(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_721,axiom,
    ! [VarCurr] :
      ( v3804(VarCurr)
    <=> ( v3805(VarCurr)
        & v3809(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_198,axiom,
    ! [VarCurr] :
      ( v3809(VarCurr)
    <=> ( ( v3797(VarCurr,bitIndex2)
        <=> $false )
        & ( v3797(VarCurr,bitIndex1)
        <=> $false )
        & ( v3797(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_720,axiom,
    ! [VarCurr] :
      ( v3805(VarCurr)
    <=> ( v3806(VarCurr)
        | v3807(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_719,axiom,
    ! [VarCurr] :
      ( v3807(VarCurr)
    <=> ( v3771(VarCurr)
        & v3808(VarCurr) ) ) ).

fof(writeUnaryOperator_301,axiom,
    ! [VarCurr] :
      ( ~ v3808(VarCurr)
    <=> v3806(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_197,axiom,
    ! [VarCurr] :
      ( v3806(VarCurr)
    <=> ( v3769(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_718,axiom,
    ! [VarCurr] :
      ( v3795(VarCurr)
    <=> ( v3796(VarCurr)
        | v3798(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_717,axiom,
    ! [VarCurr] :
      ( v3798(VarCurr)
    <=> ( v3799(VarCurr)
        & v3803(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_196,axiom,
    ! [VarCurr] :
      ( v3803(VarCurr)
    <=> ( ( v3797(VarCurr,bitIndex2)
        <=> $false )
        & ( v3797(VarCurr,bitIndex1)
        <=> $true )
        & ( v3797(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_716,axiom,
    ! [VarCurr] :
      ( v3799(VarCurr)
    <=> ( v3800(VarCurr)
        | v3801(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_715,axiom,
    ! [VarCurr] :
      ( v3801(VarCurr)
    <=> ( v3771(VarCurr)
        & v3802(VarCurr) ) ) ).

fof(writeUnaryOperator_300,axiom,
    ! [VarCurr] :
      ( ~ v3802(VarCurr)
    <=> v3800(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_195,axiom,
    ! [VarCurr] :
      ( v3800(VarCurr)
    <=> ( v3769(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_194,axiom,
    ! [VarCurr] :
      ( v3796(VarCurr)
    <=> ( ( v3797(VarCurr,bitIndex2)
        <=> $true )
        & ( v3797(VarCurr,bitIndex1)
        <=> $false )
        & ( v3797(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_983,axiom,
    ! [VarCurr] :
      ( v3797(VarCurr,bitIndex0)
    <=> v3767(VarCurr) ) ).

fof(addAssignment_982,axiom,
    ! [VarCurr] :
      ( v3797(VarCurr,bitIndex1)
    <=> v3765(VarCurr) ) ).

fof(addAssignment_981,axiom,
    ! [VarCurr] :
      ( v3797(VarCurr,bitIndex2)
    <=> v3763(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_714,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3781(VarNext)
      <=> ( v3782(VarNext)
          & v3777(VarNext) ) ) ) ).

fof(writeUnaryOperator_299,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3782(VarNext)
      <=> v3784(VarNext) ) ) ).

fof(addAssignment_980,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3784(VarNext)
      <=> v3777(VarCurr) ) ) ).

fof(addAssignment_979,axiom,
    ! [VarCurr] :
      ( v3777(VarCurr)
    <=> v3429(VarCurr) ) ).

fof(addAssignment_978,axiom,
    ! [VarCurr] :
      ( v3775(VarCurr)
    <=> $false ) ).

fof(addAssignment_977,axiom,
    ! [VarCurr] :
      ( v3773(VarCurr)
    <=> v3392(VarCurr) ) ).

fof(addAssignment_976,axiom,
    ! [VarCurr] :
      ( v3771(VarCurr)
    <=> $false ) ).

fof(addAssignment_975,axiom,
    ! [VarCurr] :
      ( v3769(VarCurr)
    <=> v3370(VarCurr,bitIndex29) ) ).

fof(addAssignment_974,axiom,
    ! [VarCurr] :
      ( v3370(VarCurr,bitIndex29)
    <=> v3372(VarCurr,bitIndex29) ) ).

fof(addAssignment_973,axiom,
    ! [VarCurr] :
      ( v3372(VarCurr,bitIndex29)
    <=> v3374(VarCurr,bitIndex29) ) ).

fof(addAssignment_972,axiom,
    ! [VarCurr] :
      ( v3374(VarCurr,bitIndex29)
    <=> v3376(VarCurr,bitIndex29) ) ).

fof(addAssignment_971,axiom,
    ! [VarCurr] :
      ( v3376(VarCurr,bitIndex29)
    <=> v3378(VarCurr,bitIndex29) ) ).

fof(addAssignment_970,axiom,
    ! [VarCurr] :
      ( v3378(VarCurr,bitIndex29)
    <=> v3380(VarCurr,bitIndex29) ) ).

fof(addAssignment_969,axiom,
    ! [VarCurr] :
      ( v3380(VarCurr,bitIndex29)
    <=> v3382(VarCurr,bitIndex29) ) ).

fof(addAssignment_968,axiom,
    ! [VarCurr] :
      ( v3382(VarCurr,bitIndex29)
    <=> v3384(VarCurr,bitIndex29) ) ).

fof(addAssignment_967,axiom,
    ! [VarCurr] :
      ( v3384(VarCurr,bitIndex29)
    <=> v3386(VarCurr,bitIndex29) ) ).

fof(addAssignment_966,axiom,
    ! [VarCurr] :
      ( v3767(VarCurr)
    <=> $false ) ).

fof(addAssignment_965,axiom,
    ! [VarCurr] :
      ( v3765(VarCurr)
    <=> $false ) ).

fof(addAssignment_964,axiom,
    ! [VarCurr] :
      ( v3763(VarCurr)
    <=> $true ) ).

fof(addAssignment_963,axiom,
    ! [VarCurr] :
      ( v3761(VarCurr)
    <=> $false ) ).

fof(addAssignment_962,axiom,
    ! [VarCurr] :
      ( v3759(VarCurr)
    <=> v3341(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_62,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3712(VarNext)
       => ( v3689(VarNext)
        <=> v3689(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_75,axiom,
    ! [VarNext] :
      ( v3712(VarNext)
     => ( v3689(VarNext)
      <=> v3747(VarNext) ) ) ).

fof(addAssignment_961,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3747(VarNext)
      <=> v3745(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_53,axiom,
    ! [VarCurr] :
      ( ~ v3691(VarCurr)
     => ( v3745(VarCurr)
      <=> v3748(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_53,axiom,
    ! [VarCurr] :
      ( v3691(VarCurr)
     => ( v3745(VarCurr)
      <=> v3693(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_52,axiom,
    ! [VarCurr] :
      ( ~ v3725(VarCurr)
     => ( v3748(VarCurr)
      <=> v3707(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_52,axiom,
    ! [VarCurr] :
      ( v3725(VarCurr)
     => ( v3748(VarCurr)
      <=> v3749(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_21,axiom,
    ! [VarCurr] :
      ( ( ~ v3728(VarCurr)
        & ~ v3730(VarCurr) )
     => ( v3749(VarCurr)
      <=> v3753(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_51,axiom,
    ! [VarCurr] :
      ( v3730(VarCurr)
     => ( v3749(VarCurr)
      <=> v3752(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_51,axiom,
    ! [VarCurr] :
      ( v3728(VarCurr)
     => ( v3749(VarCurr)
      <=> v3750(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_50,axiom,
    ! [VarCurr] :
      ( ~ v3738(VarCurr)
     => ( v3753(VarCurr)
      <=> v3707(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_50,axiom,
    ! [VarCurr] :
      ( v3738(VarCurr)
     => ( v3753(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_49,axiom,
    ! [VarCurr] :
      ( ~ v3732(VarCurr)
     => ( v3752(VarCurr)
      <=> v3707(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_49,axiom,
    ! [VarCurr] :
      ( v3732(VarCurr)
     => ( v3752(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_92,axiom,
    ! [VarCurr] :
      ( ~ v3751(VarCurr)
     => ( v3750(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_94,axiom,
    ! [VarCurr] :
      ( v3751(VarCurr)
     => ( v3750(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_193,axiom,
    ! [VarCurr] :
      ( v3751(VarCurr)
    <=> ( v3701(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_713,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3712(VarNext)
      <=> ( v3713(VarNext)
          & v3722(VarNext) ) ) ) ).

fof(addAssignment_960,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3722(VarNext)
      <=> v3720(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_712,axiom,
    ! [VarCurr] :
      ( v3720(VarCurr)
    <=> ( v3691(VarCurr)
        | v3723(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_711,axiom,
    ! [VarCurr] :
      ( v3723(VarCurr)
    <=> ( v3724(VarCurr)
        & v3744(VarCurr) ) ) ).

fof(writeUnaryOperator_298,axiom,
    ! [VarCurr] :
      ( ~ v3744(VarCurr)
    <=> v3691(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_710,axiom,
    ! [VarCurr] :
      ( v3724(VarCurr)
    <=> ( v3725(VarCurr)
        | v3742(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_709,axiom,
    ! [VarCurr] :
      ( v3742(VarCurr)
    <=> ( v3703(VarCurr)
        & v3743(VarCurr) ) ) ).

fof(writeUnaryOperator_297,axiom,
    ! [VarCurr] :
      ( ~ v3743(VarCurr)
    <=> v3705(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_708,axiom,
    ! [VarCurr] :
      ( v3725(VarCurr)
    <=> ( v3726(VarCurr)
        & v3705(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_707,axiom,
    ! [VarCurr] :
      ( v3726(VarCurr)
    <=> ( v3727(VarCurr)
        | v3736(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_706,axiom,
    ! [VarCurr] :
      ( v3736(VarCurr)
    <=> ( v3737(VarCurr)
        & v3741(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_192,axiom,
    ! [VarCurr] :
      ( v3741(VarCurr)
    <=> ( ( v3729(VarCurr,bitIndex2)
        <=> $false )
        & ( v3729(VarCurr,bitIndex1)
        <=> $false )
        & ( v3729(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_705,axiom,
    ! [VarCurr] :
      ( v3737(VarCurr)
    <=> ( v3738(VarCurr)
        | v3739(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_704,axiom,
    ! [VarCurr] :
      ( v3739(VarCurr)
    <=> ( v3703(VarCurr)
        & v3740(VarCurr) ) ) ).

fof(writeUnaryOperator_296,axiom,
    ! [VarCurr] :
      ( ~ v3740(VarCurr)
    <=> v3738(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_191,axiom,
    ! [VarCurr] :
      ( v3738(VarCurr)
    <=> ( v3701(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_703,axiom,
    ! [VarCurr] :
      ( v3727(VarCurr)
    <=> ( v3728(VarCurr)
        | v3730(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_702,axiom,
    ! [VarCurr] :
      ( v3730(VarCurr)
    <=> ( v3731(VarCurr)
        & v3735(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_190,axiom,
    ! [VarCurr] :
      ( v3735(VarCurr)
    <=> ( ( v3729(VarCurr,bitIndex2)
        <=> $false )
        & ( v3729(VarCurr,bitIndex1)
        <=> $true )
        & ( v3729(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_701,axiom,
    ! [VarCurr] :
      ( v3731(VarCurr)
    <=> ( v3732(VarCurr)
        | v3733(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_700,axiom,
    ! [VarCurr] :
      ( v3733(VarCurr)
    <=> ( v3703(VarCurr)
        & v3734(VarCurr) ) ) ).

fof(writeUnaryOperator_295,axiom,
    ! [VarCurr] :
      ( ~ v3734(VarCurr)
    <=> v3732(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_189,axiom,
    ! [VarCurr] :
      ( v3732(VarCurr)
    <=> ( v3701(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_188,axiom,
    ! [VarCurr] :
      ( v3728(VarCurr)
    <=> ( ( v3729(VarCurr,bitIndex2)
        <=> $true )
        & ( v3729(VarCurr,bitIndex1)
        <=> $false )
        & ( v3729(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_959,axiom,
    ! [VarCurr] :
      ( v3729(VarCurr,bitIndex0)
    <=> v3699(VarCurr) ) ).

fof(addAssignment_958,axiom,
    ! [VarCurr] :
      ( v3729(VarCurr,bitIndex1)
    <=> v3697(VarCurr) ) ).

fof(addAssignment_957,axiom,
    ! [VarCurr] :
      ( v3729(VarCurr,bitIndex2)
    <=> v3695(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_699,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3713(VarNext)
      <=> ( v3714(VarNext)
          & v3709(VarNext) ) ) ) ).

fof(writeUnaryOperator_294,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3714(VarNext)
      <=> v3716(VarNext) ) ) ).

fof(addAssignment_956,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3716(VarNext)
      <=> v3709(VarCurr) ) ) ).

fof(addAssignment_955,axiom,
    ! [VarCurr] :
      ( v3709(VarCurr)
    <=> v3429(VarCurr) ) ).

fof(addAssignment_954,axiom,
    ! [VarCurr] :
      ( v3707(VarCurr)
    <=> $false ) ).

fof(addAssignment_953,axiom,
    ! [VarCurr] :
      ( v3705(VarCurr)
    <=> v3392(VarCurr) ) ).

fof(addAssignment_952,axiom,
    ! [VarCurr] :
      ( v3703(VarCurr)
    <=> $false ) ).

fof(addAssignment_951,axiom,
    ! [VarCurr] :
      ( v3701(VarCurr)
    <=> v3370(VarCurr,bitIndex28) ) ).

fof(addAssignment_950,axiom,
    ! [VarCurr] :
      ( v3370(VarCurr,bitIndex28)
    <=> v3372(VarCurr,bitIndex28) ) ).

fof(addAssignment_949,axiom,
    ! [VarCurr] :
      ( v3372(VarCurr,bitIndex28)
    <=> v3374(VarCurr,bitIndex28) ) ).

fof(addAssignment_948,axiom,
    ! [VarCurr] :
      ( v3374(VarCurr,bitIndex28)
    <=> v3376(VarCurr,bitIndex28) ) ).

fof(addAssignment_947,axiom,
    ! [VarCurr] :
      ( v3376(VarCurr,bitIndex28)
    <=> v3378(VarCurr,bitIndex28) ) ).

fof(addAssignment_946,axiom,
    ! [VarCurr] :
      ( v3378(VarCurr,bitIndex28)
    <=> v3380(VarCurr,bitIndex28) ) ).

fof(addAssignment_945,axiom,
    ! [VarCurr] :
      ( v3380(VarCurr,bitIndex28)
    <=> v3382(VarCurr,bitIndex28) ) ).

fof(addAssignment_944,axiom,
    ! [VarCurr] :
      ( v3382(VarCurr,bitIndex28)
    <=> v3384(VarCurr,bitIndex28) ) ).

fof(addAssignment_943,axiom,
    ! [VarCurr] :
      ( v3384(VarCurr,bitIndex28)
    <=> v3386(VarCurr,bitIndex28) ) ).

fof(addAssignment_942,axiom,
    ! [VarCurr] :
      ( v3699(VarCurr)
    <=> $false ) ).

fof(addAssignment_941,axiom,
    ! [VarCurr] :
      ( v3697(VarCurr)
    <=> $false ) ).

fof(addAssignment_940,axiom,
    ! [VarCurr] :
      ( v3695(VarCurr)
    <=> $true ) ).

fof(addAssignment_939,axiom,
    ! [VarCurr] :
      ( v3693(VarCurr)
    <=> $false ) ).

fof(addAssignment_938,axiom,
    ! [VarCurr] :
      ( v3691(VarCurr)
    <=> v3341(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_61,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3644(VarNext)
       => ( v3621(VarNext)
        <=> v3621(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_74,axiom,
    ! [VarNext] :
      ( v3644(VarNext)
     => ( v3621(VarNext)
      <=> v3679(VarNext) ) ) ).

fof(addAssignment_937,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3679(VarNext)
      <=> v3677(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_48,axiom,
    ! [VarCurr] :
      ( ~ v3623(VarCurr)
     => ( v3677(VarCurr)
      <=> v3680(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_48,axiom,
    ! [VarCurr] :
      ( v3623(VarCurr)
     => ( v3677(VarCurr)
      <=> v3625(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_47,axiom,
    ! [VarCurr] :
      ( ~ v3657(VarCurr)
     => ( v3680(VarCurr)
      <=> v3639(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_47,axiom,
    ! [VarCurr] :
      ( v3657(VarCurr)
     => ( v3680(VarCurr)
      <=> v3681(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_20,axiom,
    ! [VarCurr] :
      ( ( ~ v3660(VarCurr)
        & ~ v3662(VarCurr) )
     => ( v3681(VarCurr)
      <=> v3685(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_46,axiom,
    ! [VarCurr] :
      ( v3662(VarCurr)
     => ( v3681(VarCurr)
      <=> v3684(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_46,axiom,
    ! [VarCurr] :
      ( v3660(VarCurr)
     => ( v3681(VarCurr)
      <=> v3682(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_45,axiom,
    ! [VarCurr] :
      ( ~ v3670(VarCurr)
     => ( v3685(VarCurr)
      <=> v3639(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_45,axiom,
    ! [VarCurr] :
      ( v3670(VarCurr)
     => ( v3685(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_44,axiom,
    ! [VarCurr] :
      ( ~ v3664(VarCurr)
     => ( v3684(VarCurr)
      <=> v3639(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_44,axiom,
    ! [VarCurr] :
      ( v3664(VarCurr)
     => ( v3684(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_91,axiom,
    ! [VarCurr] :
      ( ~ v3683(VarCurr)
     => ( v3682(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_93,axiom,
    ! [VarCurr] :
      ( v3683(VarCurr)
     => ( v3682(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_187,axiom,
    ! [VarCurr] :
      ( v3683(VarCurr)
    <=> ( v3633(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_698,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3644(VarNext)
      <=> ( v3645(VarNext)
          & v3654(VarNext) ) ) ) ).

fof(addAssignment_936,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3654(VarNext)
      <=> v3652(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_697,axiom,
    ! [VarCurr] :
      ( v3652(VarCurr)
    <=> ( v3623(VarCurr)
        | v3655(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_696,axiom,
    ! [VarCurr] :
      ( v3655(VarCurr)
    <=> ( v3656(VarCurr)
        & v3676(VarCurr) ) ) ).

fof(writeUnaryOperator_293,axiom,
    ! [VarCurr] :
      ( ~ v3676(VarCurr)
    <=> v3623(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_695,axiom,
    ! [VarCurr] :
      ( v3656(VarCurr)
    <=> ( v3657(VarCurr)
        | v3674(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_694,axiom,
    ! [VarCurr] :
      ( v3674(VarCurr)
    <=> ( v3635(VarCurr)
        & v3675(VarCurr) ) ) ).

fof(writeUnaryOperator_292,axiom,
    ! [VarCurr] :
      ( ~ v3675(VarCurr)
    <=> v3637(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_693,axiom,
    ! [VarCurr] :
      ( v3657(VarCurr)
    <=> ( v3658(VarCurr)
        & v3637(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_692,axiom,
    ! [VarCurr] :
      ( v3658(VarCurr)
    <=> ( v3659(VarCurr)
        | v3668(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_691,axiom,
    ! [VarCurr] :
      ( v3668(VarCurr)
    <=> ( v3669(VarCurr)
        & v3673(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_186,axiom,
    ! [VarCurr] :
      ( v3673(VarCurr)
    <=> ( ( v3661(VarCurr,bitIndex2)
        <=> $false )
        & ( v3661(VarCurr,bitIndex1)
        <=> $false )
        & ( v3661(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_690,axiom,
    ! [VarCurr] :
      ( v3669(VarCurr)
    <=> ( v3670(VarCurr)
        | v3671(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_689,axiom,
    ! [VarCurr] :
      ( v3671(VarCurr)
    <=> ( v3635(VarCurr)
        & v3672(VarCurr) ) ) ).

fof(writeUnaryOperator_291,axiom,
    ! [VarCurr] :
      ( ~ v3672(VarCurr)
    <=> v3670(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_185,axiom,
    ! [VarCurr] :
      ( v3670(VarCurr)
    <=> ( v3633(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_688,axiom,
    ! [VarCurr] :
      ( v3659(VarCurr)
    <=> ( v3660(VarCurr)
        | v3662(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_687,axiom,
    ! [VarCurr] :
      ( v3662(VarCurr)
    <=> ( v3663(VarCurr)
        & v3667(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_184,axiom,
    ! [VarCurr] :
      ( v3667(VarCurr)
    <=> ( ( v3661(VarCurr,bitIndex2)
        <=> $false )
        & ( v3661(VarCurr,bitIndex1)
        <=> $true )
        & ( v3661(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_686,axiom,
    ! [VarCurr] :
      ( v3663(VarCurr)
    <=> ( v3664(VarCurr)
        | v3665(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_685,axiom,
    ! [VarCurr] :
      ( v3665(VarCurr)
    <=> ( v3635(VarCurr)
        & v3666(VarCurr) ) ) ).

fof(writeUnaryOperator_290,axiom,
    ! [VarCurr] :
      ( ~ v3666(VarCurr)
    <=> v3664(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_183,axiom,
    ! [VarCurr] :
      ( v3664(VarCurr)
    <=> ( v3633(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_182,axiom,
    ! [VarCurr] :
      ( v3660(VarCurr)
    <=> ( ( v3661(VarCurr,bitIndex2)
        <=> $true )
        & ( v3661(VarCurr,bitIndex1)
        <=> $false )
        & ( v3661(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_935,axiom,
    ! [VarCurr] :
      ( v3661(VarCurr,bitIndex0)
    <=> v3631(VarCurr) ) ).

fof(addAssignment_934,axiom,
    ! [VarCurr] :
      ( v3661(VarCurr,bitIndex1)
    <=> v3629(VarCurr) ) ).

fof(addAssignment_933,axiom,
    ! [VarCurr] :
      ( v3661(VarCurr,bitIndex2)
    <=> v3627(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_684,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3645(VarNext)
      <=> ( v3646(VarNext)
          & v3641(VarNext) ) ) ) ).

fof(writeUnaryOperator_289,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3646(VarNext)
      <=> v3648(VarNext) ) ) ).

fof(addAssignment_932,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3648(VarNext)
      <=> v3641(VarCurr) ) ) ).

fof(addAssignment_931,axiom,
    ! [VarCurr] :
      ( v3641(VarCurr)
    <=> v3429(VarCurr) ) ).

fof(addAssignment_930,axiom,
    ! [VarCurr] :
      ( v3639(VarCurr)
    <=> $false ) ).

fof(addAssignment_929,axiom,
    ! [VarCurr] :
      ( v3637(VarCurr)
    <=> v3392(VarCurr) ) ).

fof(addAssignment_928,axiom,
    ! [VarCurr] :
      ( v3635(VarCurr)
    <=> $false ) ).

fof(addAssignment_927,axiom,
    ! [VarCurr] :
      ( v3633(VarCurr)
    <=> v3370(VarCurr,bitIndex27) ) ).

fof(addAssignment_926,axiom,
    ! [VarCurr] :
      ( v3370(VarCurr,bitIndex27)
    <=> v3372(VarCurr,bitIndex27) ) ).

fof(addAssignment_925,axiom,
    ! [VarCurr] :
      ( v3372(VarCurr,bitIndex27)
    <=> v3374(VarCurr,bitIndex27) ) ).

fof(addAssignment_924,axiom,
    ! [VarCurr] :
      ( v3374(VarCurr,bitIndex27)
    <=> v3376(VarCurr,bitIndex27) ) ).

fof(addAssignment_923,axiom,
    ! [VarCurr] :
      ( v3376(VarCurr,bitIndex27)
    <=> v3378(VarCurr,bitIndex27) ) ).

fof(addAssignment_922,axiom,
    ! [VarCurr] :
      ( v3378(VarCurr,bitIndex27)
    <=> v3380(VarCurr,bitIndex27) ) ).

fof(addAssignment_921,axiom,
    ! [VarCurr] :
      ( v3380(VarCurr,bitIndex27)
    <=> v3382(VarCurr,bitIndex27) ) ).

fof(addAssignment_920,axiom,
    ! [VarCurr] :
      ( v3382(VarCurr,bitIndex27)
    <=> v3384(VarCurr,bitIndex27) ) ).

fof(addAssignment_919,axiom,
    ! [VarCurr] :
      ( v3384(VarCurr,bitIndex27)
    <=> v3386(VarCurr,bitIndex27) ) ).

fof(addAssignment_918,axiom,
    ! [VarCurr] :
      ( v3631(VarCurr)
    <=> $false ) ).

fof(addAssignment_917,axiom,
    ! [VarCurr] :
      ( v3629(VarCurr)
    <=> $false ) ).

fof(addAssignment_916,axiom,
    ! [VarCurr] :
      ( v3627(VarCurr)
    <=> $true ) ).

fof(addAssignment_915,axiom,
    ! [VarCurr] :
      ( v3625(VarCurr)
    <=> $false ) ).

fof(addAssignment_914,axiom,
    ! [VarCurr] :
      ( v3623(VarCurr)
    <=> v3341(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_60,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3576(VarNext)
       => ( v3553(VarNext)
        <=> v3553(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_73,axiom,
    ! [VarNext] :
      ( v3576(VarNext)
     => ( v3553(VarNext)
      <=> v3611(VarNext) ) ) ).

fof(addAssignment_913,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3611(VarNext)
      <=> v3609(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_43,axiom,
    ! [VarCurr] :
      ( ~ v3555(VarCurr)
     => ( v3609(VarCurr)
      <=> v3612(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_43,axiom,
    ! [VarCurr] :
      ( v3555(VarCurr)
     => ( v3609(VarCurr)
      <=> v3557(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_42,axiom,
    ! [VarCurr] :
      ( ~ v3589(VarCurr)
     => ( v3612(VarCurr)
      <=> v3571(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_42,axiom,
    ! [VarCurr] :
      ( v3589(VarCurr)
     => ( v3612(VarCurr)
      <=> v3613(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_19,axiom,
    ! [VarCurr] :
      ( ( ~ v3592(VarCurr)
        & ~ v3594(VarCurr) )
     => ( v3613(VarCurr)
      <=> v3617(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_41,axiom,
    ! [VarCurr] :
      ( v3594(VarCurr)
     => ( v3613(VarCurr)
      <=> v3616(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_41,axiom,
    ! [VarCurr] :
      ( v3592(VarCurr)
     => ( v3613(VarCurr)
      <=> v3614(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_40,axiom,
    ! [VarCurr] :
      ( ~ v3602(VarCurr)
     => ( v3617(VarCurr)
      <=> v3571(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_40,axiom,
    ! [VarCurr] :
      ( v3602(VarCurr)
     => ( v3617(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_39,axiom,
    ! [VarCurr] :
      ( ~ v3596(VarCurr)
     => ( v3616(VarCurr)
      <=> v3571(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_39,axiom,
    ! [VarCurr] :
      ( v3596(VarCurr)
     => ( v3616(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_90,axiom,
    ! [VarCurr] :
      ( ~ v3615(VarCurr)
     => ( v3614(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_92,axiom,
    ! [VarCurr] :
      ( v3615(VarCurr)
     => ( v3614(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_181,axiom,
    ! [VarCurr] :
      ( v3615(VarCurr)
    <=> ( v3565(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_683,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3576(VarNext)
      <=> ( v3577(VarNext)
          & v3586(VarNext) ) ) ) ).

fof(addAssignment_912,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3586(VarNext)
      <=> v3584(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_682,axiom,
    ! [VarCurr] :
      ( v3584(VarCurr)
    <=> ( v3555(VarCurr)
        | v3587(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_681,axiom,
    ! [VarCurr] :
      ( v3587(VarCurr)
    <=> ( v3588(VarCurr)
        & v3608(VarCurr) ) ) ).

fof(writeUnaryOperator_288,axiom,
    ! [VarCurr] :
      ( ~ v3608(VarCurr)
    <=> v3555(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_680,axiom,
    ! [VarCurr] :
      ( v3588(VarCurr)
    <=> ( v3589(VarCurr)
        | v3606(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_679,axiom,
    ! [VarCurr] :
      ( v3606(VarCurr)
    <=> ( v3567(VarCurr)
        & v3607(VarCurr) ) ) ).

fof(writeUnaryOperator_287,axiom,
    ! [VarCurr] :
      ( ~ v3607(VarCurr)
    <=> v3569(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_678,axiom,
    ! [VarCurr] :
      ( v3589(VarCurr)
    <=> ( v3590(VarCurr)
        & v3569(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_677,axiom,
    ! [VarCurr] :
      ( v3590(VarCurr)
    <=> ( v3591(VarCurr)
        | v3600(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_676,axiom,
    ! [VarCurr] :
      ( v3600(VarCurr)
    <=> ( v3601(VarCurr)
        & v3605(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_180,axiom,
    ! [VarCurr] :
      ( v3605(VarCurr)
    <=> ( ( v3593(VarCurr,bitIndex2)
        <=> $false )
        & ( v3593(VarCurr,bitIndex1)
        <=> $false )
        & ( v3593(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_675,axiom,
    ! [VarCurr] :
      ( v3601(VarCurr)
    <=> ( v3602(VarCurr)
        | v3603(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_674,axiom,
    ! [VarCurr] :
      ( v3603(VarCurr)
    <=> ( v3567(VarCurr)
        & v3604(VarCurr) ) ) ).

fof(writeUnaryOperator_286,axiom,
    ! [VarCurr] :
      ( ~ v3604(VarCurr)
    <=> v3602(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_179,axiom,
    ! [VarCurr] :
      ( v3602(VarCurr)
    <=> ( v3565(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_673,axiom,
    ! [VarCurr] :
      ( v3591(VarCurr)
    <=> ( v3592(VarCurr)
        | v3594(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_672,axiom,
    ! [VarCurr] :
      ( v3594(VarCurr)
    <=> ( v3595(VarCurr)
        & v3599(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_178,axiom,
    ! [VarCurr] :
      ( v3599(VarCurr)
    <=> ( ( v3593(VarCurr,bitIndex2)
        <=> $false )
        & ( v3593(VarCurr,bitIndex1)
        <=> $true )
        & ( v3593(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_671,axiom,
    ! [VarCurr] :
      ( v3595(VarCurr)
    <=> ( v3596(VarCurr)
        | v3597(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_670,axiom,
    ! [VarCurr] :
      ( v3597(VarCurr)
    <=> ( v3567(VarCurr)
        & v3598(VarCurr) ) ) ).

fof(writeUnaryOperator_285,axiom,
    ! [VarCurr] :
      ( ~ v3598(VarCurr)
    <=> v3596(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_177,axiom,
    ! [VarCurr] :
      ( v3596(VarCurr)
    <=> ( v3565(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_176,axiom,
    ! [VarCurr] :
      ( v3592(VarCurr)
    <=> ( ( v3593(VarCurr,bitIndex2)
        <=> $true )
        & ( v3593(VarCurr,bitIndex1)
        <=> $false )
        & ( v3593(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_911,axiom,
    ! [VarCurr] :
      ( v3593(VarCurr,bitIndex0)
    <=> v3563(VarCurr) ) ).

fof(addAssignment_910,axiom,
    ! [VarCurr] :
      ( v3593(VarCurr,bitIndex1)
    <=> v3561(VarCurr) ) ).

fof(addAssignment_909,axiom,
    ! [VarCurr] :
      ( v3593(VarCurr,bitIndex2)
    <=> v3559(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_669,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3577(VarNext)
      <=> ( v3578(VarNext)
          & v3573(VarNext) ) ) ) ).

fof(writeUnaryOperator_284,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3578(VarNext)
      <=> v3580(VarNext) ) ) ).

fof(addAssignment_908,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3580(VarNext)
      <=> v3573(VarCurr) ) ) ).

fof(addAssignment_907,axiom,
    ! [VarCurr] :
      ( v3573(VarCurr)
    <=> v3429(VarCurr) ) ).

fof(addAssignment_906,axiom,
    ! [VarCurr] :
      ( v3571(VarCurr)
    <=> $false ) ).

fof(addAssignment_905,axiom,
    ! [VarCurr] :
      ( v3569(VarCurr)
    <=> v3392(VarCurr) ) ).

fof(addAssignment_904,axiom,
    ! [VarCurr] :
      ( v3567(VarCurr)
    <=> $false ) ).

fof(addAssignment_903,axiom,
    ! [VarCurr] :
      ( v3565(VarCurr)
    <=> v3370(VarCurr,bitIndex26) ) ).

fof(addAssignment_902,axiom,
    ! [VarCurr] :
      ( v3370(VarCurr,bitIndex26)
    <=> v3372(VarCurr,bitIndex26) ) ).

fof(addAssignment_901,axiom,
    ! [VarCurr] :
      ( v3372(VarCurr,bitIndex26)
    <=> v3374(VarCurr,bitIndex26) ) ).

fof(addAssignment_900,axiom,
    ! [VarCurr] :
      ( v3374(VarCurr,bitIndex26)
    <=> v3376(VarCurr,bitIndex26) ) ).

fof(addAssignment_899,axiom,
    ! [VarCurr] :
      ( v3376(VarCurr,bitIndex26)
    <=> v3378(VarCurr,bitIndex26) ) ).

fof(addAssignment_898,axiom,
    ! [VarCurr] :
      ( v3378(VarCurr,bitIndex26)
    <=> v3380(VarCurr,bitIndex26) ) ).

fof(addAssignment_897,axiom,
    ! [VarCurr] :
      ( v3380(VarCurr,bitIndex26)
    <=> v3382(VarCurr,bitIndex26) ) ).

fof(addAssignment_896,axiom,
    ! [VarCurr] :
      ( v3382(VarCurr,bitIndex26)
    <=> v3384(VarCurr,bitIndex26) ) ).

fof(addAssignment_895,axiom,
    ! [VarCurr] :
      ( v3384(VarCurr,bitIndex26)
    <=> v3386(VarCurr,bitIndex26) ) ).

fof(addAssignment_894,axiom,
    ! [VarCurr] :
      ( v3563(VarCurr)
    <=> $false ) ).

fof(addAssignment_893,axiom,
    ! [VarCurr] :
      ( v3561(VarCurr)
    <=> $false ) ).

fof(addAssignment_892,axiom,
    ! [VarCurr] :
      ( v3559(VarCurr)
    <=> $true ) ).

fof(addAssignment_891,axiom,
    ! [VarCurr] :
      ( v3557(VarCurr)
    <=> $false ) ).

fof(addAssignment_890,axiom,
    ! [VarCurr] :
      ( v3555(VarCurr)
    <=> v3341(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_59,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3508(VarNext)
       => ( v3485(VarNext)
        <=> v3485(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_72,axiom,
    ! [VarNext] :
      ( v3508(VarNext)
     => ( v3485(VarNext)
      <=> v3543(VarNext) ) ) ).

fof(addAssignment_889,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3543(VarNext)
      <=> v3541(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_38,axiom,
    ! [VarCurr] :
      ( ~ v3487(VarCurr)
     => ( v3541(VarCurr)
      <=> v3544(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_38,axiom,
    ! [VarCurr] :
      ( v3487(VarCurr)
     => ( v3541(VarCurr)
      <=> v3489(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_37,axiom,
    ! [VarCurr] :
      ( ~ v3521(VarCurr)
     => ( v3544(VarCurr)
      <=> v3503(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_37,axiom,
    ! [VarCurr] :
      ( v3521(VarCurr)
     => ( v3544(VarCurr)
      <=> v3545(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_18,axiom,
    ! [VarCurr] :
      ( ( ~ v3524(VarCurr)
        & ~ v3526(VarCurr) )
     => ( v3545(VarCurr)
      <=> v3549(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_36,axiom,
    ! [VarCurr] :
      ( v3526(VarCurr)
     => ( v3545(VarCurr)
      <=> v3548(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_36,axiom,
    ! [VarCurr] :
      ( v3524(VarCurr)
     => ( v3545(VarCurr)
      <=> v3546(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_35,axiom,
    ! [VarCurr] :
      ( ~ v3534(VarCurr)
     => ( v3549(VarCurr)
      <=> v3503(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_35,axiom,
    ! [VarCurr] :
      ( v3534(VarCurr)
     => ( v3549(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_34,axiom,
    ! [VarCurr] :
      ( ~ v3528(VarCurr)
     => ( v3548(VarCurr)
      <=> v3503(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_34,axiom,
    ! [VarCurr] :
      ( v3528(VarCurr)
     => ( v3548(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_89,axiom,
    ! [VarCurr] :
      ( ~ v3547(VarCurr)
     => ( v3546(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_91,axiom,
    ! [VarCurr] :
      ( v3547(VarCurr)
     => ( v3546(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_175,axiom,
    ! [VarCurr] :
      ( v3547(VarCurr)
    <=> ( v3497(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_668,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3508(VarNext)
      <=> ( v3509(VarNext)
          & v3518(VarNext) ) ) ) ).

fof(addAssignment_888,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3518(VarNext)
      <=> v3516(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_667,axiom,
    ! [VarCurr] :
      ( v3516(VarCurr)
    <=> ( v3487(VarCurr)
        | v3519(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_666,axiom,
    ! [VarCurr] :
      ( v3519(VarCurr)
    <=> ( v3520(VarCurr)
        & v3540(VarCurr) ) ) ).

fof(writeUnaryOperator_283,axiom,
    ! [VarCurr] :
      ( ~ v3540(VarCurr)
    <=> v3487(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_665,axiom,
    ! [VarCurr] :
      ( v3520(VarCurr)
    <=> ( v3521(VarCurr)
        | v3538(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_664,axiom,
    ! [VarCurr] :
      ( v3538(VarCurr)
    <=> ( v3499(VarCurr)
        & v3539(VarCurr) ) ) ).

fof(writeUnaryOperator_282,axiom,
    ! [VarCurr] :
      ( ~ v3539(VarCurr)
    <=> v3501(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_663,axiom,
    ! [VarCurr] :
      ( v3521(VarCurr)
    <=> ( v3522(VarCurr)
        & v3501(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_662,axiom,
    ! [VarCurr] :
      ( v3522(VarCurr)
    <=> ( v3523(VarCurr)
        | v3532(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_661,axiom,
    ! [VarCurr] :
      ( v3532(VarCurr)
    <=> ( v3533(VarCurr)
        & v3537(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_174,axiom,
    ! [VarCurr] :
      ( v3537(VarCurr)
    <=> ( ( v3525(VarCurr,bitIndex2)
        <=> $false )
        & ( v3525(VarCurr,bitIndex1)
        <=> $false )
        & ( v3525(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_660,axiom,
    ! [VarCurr] :
      ( v3533(VarCurr)
    <=> ( v3534(VarCurr)
        | v3535(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_659,axiom,
    ! [VarCurr] :
      ( v3535(VarCurr)
    <=> ( v3499(VarCurr)
        & v3536(VarCurr) ) ) ).

fof(writeUnaryOperator_281,axiom,
    ! [VarCurr] :
      ( ~ v3536(VarCurr)
    <=> v3534(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_173,axiom,
    ! [VarCurr] :
      ( v3534(VarCurr)
    <=> ( v3497(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_658,axiom,
    ! [VarCurr] :
      ( v3523(VarCurr)
    <=> ( v3524(VarCurr)
        | v3526(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_657,axiom,
    ! [VarCurr] :
      ( v3526(VarCurr)
    <=> ( v3527(VarCurr)
        & v3531(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_172,axiom,
    ! [VarCurr] :
      ( v3531(VarCurr)
    <=> ( ( v3525(VarCurr,bitIndex2)
        <=> $false )
        & ( v3525(VarCurr,bitIndex1)
        <=> $true )
        & ( v3525(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_656,axiom,
    ! [VarCurr] :
      ( v3527(VarCurr)
    <=> ( v3528(VarCurr)
        | v3529(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_655,axiom,
    ! [VarCurr] :
      ( v3529(VarCurr)
    <=> ( v3499(VarCurr)
        & v3530(VarCurr) ) ) ).

fof(writeUnaryOperator_280,axiom,
    ! [VarCurr] :
      ( ~ v3530(VarCurr)
    <=> v3528(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_171,axiom,
    ! [VarCurr] :
      ( v3528(VarCurr)
    <=> ( v3497(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_170,axiom,
    ! [VarCurr] :
      ( v3524(VarCurr)
    <=> ( ( v3525(VarCurr,bitIndex2)
        <=> $true )
        & ( v3525(VarCurr,bitIndex1)
        <=> $false )
        & ( v3525(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_887,axiom,
    ! [VarCurr] :
      ( v3525(VarCurr,bitIndex0)
    <=> v3495(VarCurr) ) ).

fof(addAssignment_886,axiom,
    ! [VarCurr] :
      ( v3525(VarCurr,bitIndex1)
    <=> v3493(VarCurr) ) ).

fof(addAssignment_885,axiom,
    ! [VarCurr] :
      ( v3525(VarCurr,bitIndex2)
    <=> v3491(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_654,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3509(VarNext)
      <=> ( v3510(VarNext)
          & v3505(VarNext) ) ) ) ).

fof(writeUnaryOperator_279,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3510(VarNext)
      <=> v3512(VarNext) ) ) ).

fof(addAssignment_884,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3512(VarNext)
      <=> v3505(VarCurr) ) ) ).

fof(addAssignment_883,axiom,
    ! [VarCurr] :
      ( v3505(VarCurr)
    <=> v3429(VarCurr) ) ).

fof(addAssignment_882,axiom,
    ! [VarCurr] :
      ( v3503(VarCurr)
    <=> $false ) ).

fof(addAssignment_881,axiom,
    ! [VarCurr] :
      ( v3501(VarCurr)
    <=> v3392(VarCurr) ) ).

fof(addAssignment_880,axiom,
    ! [VarCurr] :
      ( v3499(VarCurr)
    <=> $false ) ).

fof(addAssignment_879,axiom,
    ! [VarCurr] :
      ( v3497(VarCurr)
    <=> v3370(VarCurr,bitIndex25) ) ).

fof(addAssignment_878,axiom,
    ! [VarCurr] :
      ( v3370(VarCurr,bitIndex25)
    <=> v3372(VarCurr,bitIndex25) ) ).

fof(addAssignment_877,axiom,
    ! [VarCurr] :
      ( v3372(VarCurr,bitIndex25)
    <=> v3374(VarCurr,bitIndex25) ) ).

fof(addAssignment_876,axiom,
    ! [VarCurr] :
      ( v3374(VarCurr,bitIndex25)
    <=> v3376(VarCurr,bitIndex25) ) ).

fof(addAssignment_875,axiom,
    ! [VarCurr] :
      ( v3376(VarCurr,bitIndex25)
    <=> v3378(VarCurr,bitIndex25) ) ).

fof(addAssignment_874,axiom,
    ! [VarCurr] :
      ( v3378(VarCurr,bitIndex25)
    <=> v3380(VarCurr,bitIndex25) ) ).

fof(addAssignment_873,axiom,
    ! [VarCurr] :
      ( v3380(VarCurr,bitIndex25)
    <=> v3382(VarCurr,bitIndex25) ) ).

fof(addAssignment_872,axiom,
    ! [VarCurr] :
      ( v3382(VarCurr,bitIndex25)
    <=> v3384(VarCurr,bitIndex25) ) ).

fof(addAssignment_871,axiom,
    ! [VarCurr] :
      ( v3384(VarCurr,bitIndex25)
    <=> v3386(VarCurr,bitIndex25) ) ).

fof(addAssignment_870,axiom,
    ! [VarCurr] :
      ( v3495(VarCurr)
    <=> $false ) ).

fof(addAssignment_869,axiom,
    ! [VarCurr] :
      ( v3493(VarCurr)
    <=> $false ) ).

fof(addAssignment_868,axiom,
    ! [VarCurr] :
      ( v3491(VarCurr)
    <=> $true ) ).

fof(addAssignment_867,axiom,
    ! [VarCurr] :
      ( v3489(VarCurr)
    <=> $false ) ).

fof(addAssignment_866,axiom,
    ! [VarCurr] :
      ( v3487(VarCurr)
    <=> v3341(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_58,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3440(VarNext)
       => ( v3337(VarNext)
        <=> v3337(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_71,axiom,
    ! [VarNext] :
      ( v3440(VarNext)
     => ( v3337(VarNext)
      <=> v3475(VarNext) ) ) ).

fof(addAssignment_865,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3475(VarNext)
      <=> v3473(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_33,axiom,
    ! [VarCurr] :
      ( ~ v3339(VarCurr)
     => ( v3473(VarCurr)
      <=> v3476(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_33,axiom,
    ! [VarCurr] :
      ( v3339(VarCurr)
     => ( v3473(VarCurr)
      <=> v3360(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_32,axiom,
    ! [VarCurr] :
      ( ~ v3453(VarCurr)
     => ( v3476(VarCurr)
      <=> v3425(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_32,axiom,
    ! [VarCurr] :
      ( v3453(VarCurr)
     => ( v3476(VarCurr)
      <=> v3477(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_17,axiom,
    ! [VarCurr] :
      ( ( ~ v3456(VarCurr)
        & ~ v3458(VarCurr) )
     => ( v3477(VarCurr)
      <=> v3481(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_31,axiom,
    ! [VarCurr] :
      ( v3458(VarCurr)
     => ( v3477(VarCurr)
      <=> v3480(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_31,axiom,
    ! [VarCurr] :
      ( v3456(VarCurr)
     => ( v3477(VarCurr)
      <=> v3478(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_30,axiom,
    ! [VarCurr] :
      ( ~ v3466(VarCurr)
     => ( v3481(VarCurr)
      <=> v3425(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_30,axiom,
    ! [VarCurr] :
      ( v3466(VarCurr)
     => ( v3481(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_29,axiom,
    ! [VarCurr] :
      ( ~ v3460(VarCurr)
     => ( v3480(VarCurr)
      <=> v3425(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_29,axiom,
    ! [VarCurr] :
      ( v3460(VarCurr)
     => ( v3480(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_88,axiom,
    ! [VarCurr] :
      ( ~ v3479(VarCurr)
     => ( v3478(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_90,axiom,
    ! [VarCurr] :
      ( v3479(VarCurr)
     => ( v3478(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_169,axiom,
    ! [VarCurr] :
      ( v3479(VarCurr)
    <=> ( v3368(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_653,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3440(VarNext)
      <=> ( v3441(VarNext)
          & v3450(VarNext) ) ) ) ).

fof(addAssignment_864,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3450(VarNext)
      <=> v3448(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_652,axiom,
    ! [VarCurr] :
      ( v3448(VarCurr)
    <=> ( v3339(VarCurr)
        | v3451(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_651,axiom,
    ! [VarCurr] :
      ( v3451(VarCurr)
    <=> ( v3452(VarCurr)
        & v3472(VarCurr) ) ) ).

fof(writeUnaryOperator_278,axiom,
    ! [VarCurr] :
      ( ~ v3472(VarCurr)
    <=> v3339(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_650,axiom,
    ! [VarCurr] :
      ( v3452(VarCurr)
    <=> ( v3453(VarCurr)
        | v3470(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_649,axiom,
    ! [VarCurr] :
      ( v3470(VarCurr)
    <=> ( v3388(VarCurr)
        & v3471(VarCurr) ) ) ).

fof(writeUnaryOperator_277,axiom,
    ! [VarCurr] :
      ( ~ v3471(VarCurr)
    <=> v3390(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_648,axiom,
    ! [VarCurr] :
      ( v3453(VarCurr)
    <=> ( v3454(VarCurr)
        & v3390(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_647,axiom,
    ! [VarCurr] :
      ( v3454(VarCurr)
    <=> ( v3455(VarCurr)
        | v3464(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_646,axiom,
    ! [VarCurr] :
      ( v3464(VarCurr)
    <=> ( v3465(VarCurr)
        & v3469(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_168,axiom,
    ! [VarCurr] :
      ( v3469(VarCurr)
    <=> ( ( v3457(VarCurr,bitIndex2)
        <=> $false )
        & ( v3457(VarCurr,bitIndex1)
        <=> $false )
        & ( v3457(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_645,axiom,
    ! [VarCurr] :
      ( v3465(VarCurr)
    <=> ( v3466(VarCurr)
        | v3467(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_644,axiom,
    ! [VarCurr] :
      ( v3467(VarCurr)
    <=> ( v3388(VarCurr)
        & v3468(VarCurr) ) ) ).

fof(writeUnaryOperator_276,axiom,
    ! [VarCurr] :
      ( ~ v3468(VarCurr)
    <=> v3466(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_167,axiom,
    ! [VarCurr] :
      ( v3466(VarCurr)
    <=> ( v3368(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_643,axiom,
    ! [VarCurr] :
      ( v3455(VarCurr)
    <=> ( v3456(VarCurr)
        | v3458(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_642,axiom,
    ! [VarCurr] :
      ( v3458(VarCurr)
    <=> ( v3459(VarCurr)
        & v3463(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_166,axiom,
    ! [VarCurr] :
      ( v3463(VarCurr)
    <=> ( ( v3457(VarCurr,bitIndex2)
        <=> $false )
        & ( v3457(VarCurr,bitIndex1)
        <=> $true )
        & ( v3457(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_641,axiom,
    ! [VarCurr] :
      ( v3459(VarCurr)
    <=> ( v3460(VarCurr)
        | v3461(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_640,axiom,
    ! [VarCurr] :
      ( v3461(VarCurr)
    <=> ( v3388(VarCurr)
        & v3462(VarCurr) ) ) ).

fof(writeUnaryOperator_275,axiom,
    ! [VarCurr] :
      ( ~ v3462(VarCurr)
    <=> v3460(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_165,axiom,
    ! [VarCurr] :
      ( v3460(VarCurr)
    <=> ( v3368(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_164,axiom,
    ! [VarCurr] :
      ( v3456(VarCurr)
    <=> ( ( v3457(VarCurr,bitIndex2)
        <=> $true )
        & ( v3457(VarCurr,bitIndex1)
        <=> $false )
        & ( v3457(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_863,axiom,
    ! [VarCurr] :
      ( v3457(VarCurr,bitIndex0)
    <=> v3366(VarCurr) ) ).

fof(addAssignment_862,axiom,
    ! [VarCurr] :
      ( v3457(VarCurr,bitIndex1)
    <=> v3364(VarCurr) ) ).

fof(addAssignment_861,axiom,
    ! [VarCurr] :
      ( v3457(VarCurr,bitIndex2)
    <=> v3362(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_639,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3441(VarNext)
      <=> ( v3442(VarNext)
          & v3427(VarNext) ) ) ) ).

fof(writeUnaryOperator_274,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3442(VarNext)
      <=> v3444(VarNext) ) ) ).

fof(addAssignment_860,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3444(VarNext)
      <=> v3427(VarCurr) ) ) ).

fof(addAssignment_859,axiom,
    ! [VarCurr] :
      ( v3427(VarCurr)
    <=> v3429(VarCurr) ) ).

fof(addAssignment_858,axiom,
    ! [VarCurr] :
      ( v3429(VarCurr)
    <=> v3431(VarCurr) ) ).

fof(addAssignment_857,axiom,
    ! [VarCurr] :
      ( v3431(VarCurr)
    <=> v3433(VarCurr) ) ).

fof(addAssignment_856,axiom,
    ! [VarCurr] :
      ( v3433(VarCurr)
    <=> v3435(VarCurr) ) ).

fof(addAssignment_855,axiom,
    ! [VarCurr] :
      ( v3435(VarCurr)
    <=> v3437(VarCurr) ) ).

fof(addAssignment_854,axiom,
    ! [VarCurr] :
      ( v3437(VarCurr)
    <=> v1(VarCurr) ) ).

fof(addAssignment_853,axiom,
    ! [VarCurr] :
      ( v3425(VarCurr)
    <=> $false ) ).

fof(addAssignment_852,axiom,
    ! [VarCurr] :
      ( v3390(VarCurr)
    <=> v3392(VarCurr) ) ).

fof(addAssignment_851,axiom,
    ! [VarCurr] :
      ( v3392(VarCurr)
    <=> v3394(VarCurr) ) ).

fof(addAssignment_850,axiom,
    ! [VarCurr] :
      ( v3394(VarCurr)
    <=> v3396(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_638,axiom,
    ! [VarCurr] :
      ( v3396(VarCurr)
    <=> ( v3398(VarCurr)
        & v3410(VarCurr) ) ) ).

fof(addAssignment_849,axiom,
    ! [VarCurr] :
      ( v3410(VarCurr)
    <=> v3412(VarCurr) ) ).

fof(addAssignment_848,axiom,
    ! [VarCurr] :
      ( v3412(VarCurr)
    <=> v3414(VarCurr) ) ).

fof(addAssignment_847,axiom,
    ! [VarCurr] :
      ( v3414(VarCurr)
    <=> v3416(VarCurr) ) ).

fof(addAssignment_846,axiom,
    ! [VarCurr] :
      ( v3416(VarCurr)
    <=> v3418(VarCurr) ) ).

fof(addAssignment_845,axiom,
    ! [VarCurr] :
      ( v3418(VarCurr)
    <=> v3420(VarCurr) ) ).

fof(addAssignment_844,axiom,
    ! [VarCurr] :
      ( v3420(VarCurr)
    <=> v3422(VarCurr) ) ).

fof(addAssignment_843,axiom,
    ! [VarCurr] :
      ( v3398(VarCurr)
    <=> v3400(VarCurr) ) ).

fof(addAssignment_842,axiom,
    ! [VarCurr] :
      ( v3400(VarCurr)
    <=> v3402(VarCurr) ) ).

fof(addAssignment_841,axiom,
    ! [VarCurr] :
      ( v3402(VarCurr)
    <=> v3404(VarCurr) ) ).

fof(addAssignment_840,axiom,
    ! [VarCurr] :
      ( v3404(VarCurr)
    <=> v3406(VarCurr) ) ).

fof(addAssignment_839,axiom,
    ! [VarCurr] :
      ( v3406(VarCurr)
    <=> v3408(VarCurr) ) ).

fof(addAssignment_838,axiom,
    ! [VarCurr] :
      ( v3388(VarCurr)
    <=> $false ) ).

fof(addAssignment_837,axiom,
    ! [VarCurr] :
      ( v3368(VarCurr)
    <=> v3370(VarCurr,bitIndex24) ) ).

fof(addAssignment_836,axiom,
    ! [VarCurr] :
      ( v3370(VarCurr,bitIndex24)
    <=> v3372(VarCurr,bitIndex24) ) ).

fof(addAssignment_835,axiom,
    ! [VarCurr] :
      ( v3372(VarCurr,bitIndex24)
    <=> v3374(VarCurr,bitIndex24) ) ).

fof(addAssignment_834,axiom,
    ! [VarCurr] :
      ( v3374(VarCurr,bitIndex24)
    <=> v3376(VarCurr,bitIndex24) ) ).

fof(addAssignment_833,axiom,
    ! [VarCurr] :
      ( v3376(VarCurr,bitIndex24)
    <=> v3378(VarCurr,bitIndex24) ) ).

fof(addAssignment_832,axiom,
    ! [VarCurr] :
      ( v3378(VarCurr,bitIndex24)
    <=> v3380(VarCurr,bitIndex24) ) ).

fof(addAssignment_831,axiom,
    ! [VarCurr] :
      ( v3380(VarCurr,bitIndex24)
    <=> v3382(VarCurr,bitIndex24) ) ).

fof(addAssignment_830,axiom,
    ! [VarCurr] :
      ( v3382(VarCurr,bitIndex24)
    <=> v3384(VarCurr,bitIndex24) ) ).

fof(addAssignment_829,axiom,
    ! [VarCurr] :
      ( v3384(VarCurr,bitIndex24)
    <=> v3386(VarCurr,bitIndex24) ) ).

fof(addAssignment_828,axiom,
    ! [VarCurr] :
      ( v3366(VarCurr)
    <=> $false ) ).

fof(addAssignment_827,axiom,
    ! [VarCurr] :
      ( v3364(VarCurr)
    <=> $false ) ).

fof(addAssignment_826,axiom,
    ! [VarCurr] :
      ( v3362(VarCurr)
    <=> $true ) ).

fof(addAssignment_825,axiom,
    ! [VarCurr] :
      ( v3360(VarCurr)
    <=> $false ) ).

fof(addAssignment_824,axiom,
    ! [VarCurr] :
      ( v3339(VarCurr)
    <=> v3341(VarCurr) ) ).

fof(writeUnaryOperator_273,axiom,
    ! [VarCurr] :
      ( ~ v3341(VarCurr)
    <=> v3343(VarCurr) ) ).

fof(addAssignment_823,axiom,
    ! [VarCurr] :
      ( v3343(VarCurr)
    <=> v3345(VarCurr) ) ).

fof(addAssignment_822,axiom,
    ! [VarCurr] :
      ( v3345(VarCurr)
    <=> v3347(VarCurr) ) ).

fof(addAssignment_821,axiom,
    ! [VarCurr] :
      ( v3347(VarCurr)
    <=> v3349(VarCurr) ) ).

fof(addAssignment_820,axiom,
    ! [VarCurr] :
      ( v3349(VarCurr)
    <=> v3351(VarCurr) ) ).

fof(addAssignment_819,axiom,
    ! [VarCurr] :
      ( v3351(VarCurr)
    <=> v3353(VarCurr) ) ).

fof(addAssignment_818,axiom,
    ! [VarCurr] :
      ( v3353(VarCurr)
    <=> v3355(VarCurr) ) ).

fof(addAssignment_817,axiom,
    ! [VarCurr] :
      ( v3355(VarCurr)
    <=> v3357(VarCurr) ) ).

fof(addAssignment_816,axiom,
    ! [VarCurr] :
      ( v3357(VarCurr)
    <=> v14(VarCurr) ) ).

fof(addAssignment_815,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v522(VarCurr,B)
      <=> v524(VarCurr,B) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_87,axiom,
    ! [VarCurr] :
      ( ~ v291(VarCurr,bitIndex1)
     => ! [B] :
          ( range_6_0(B)
         => ( v3307(VarCurr,B)
          <=> b1001010(B) ) ) ) ).

fof(bitBlastConstant_280,axiom,
    b1001010(bitIndex6) ).

fof(bitBlastConstant_279,axiom,
    ~ b1001010(bitIndex5) ).

fof(bitBlastConstant_278,axiom,
    ~ b1001010(bitIndex4) ).

fof(bitBlastConstant_277,axiom,
    b1001010(bitIndex3) ).

fof(bitBlastConstant_276,axiom,
    ~ b1001010(bitIndex2) ).

fof(bitBlastConstant_275,axiom,
    b1001010(bitIndex1) ).

fof(bitBlastConstant_274,axiom,
    ~ b1001010(bitIndex0) ).

fof(addConditionBooleanCondEqualRangesThenBranch_89,axiom,
    ! [VarCurr] :
      ( v291(VarCurr,bitIndex1)
     => ! [B] :
          ( range_6_0(B)
         => ( v3307(VarCurr,B)
          <=> b1111010(B) ) ) ) ).

fof(bitBlastConstant_273,axiom,
    b1111010(bitIndex6) ).

fof(bitBlastConstant_272,axiom,
    b1111010(bitIndex5) ).

fof(bitBlastConstant_271,axiom,
    b1111010(bitIndex4) ).

fof(bitBlastConstant_270,axiom,
    b1111010(bitIndex3) ).

fof(bitBlastConstant_269,axiom,
    ~ b1111010(bitIndex2) ).

fof(bitBlastConstant_268,axiom,
    b1111010(bitIndex1) ).

fof(bitBlastConstant_267,axiom,
    ~ b1111010(bitIndex0) ).

fof(addAssignment_814,axiom,
    ! [VarCurr,B] :
      ( range_1_0(B)
     => ( v3298(VarCurr,B)
      <=> v3300(VarCurr,B) ) ) ).

fof(addAssignment_813,axiom,
    ! [VarCurr,B] :
      ( range_1_0(B)
     => ( v3300(VarCurr,B)
      <=> v3302(VarCurr,B) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_86,axiom,
    ! [VarCurr] :
      ( ~ v3304(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v3302(VarCurr,B)
          <=> v3305(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_88,axiom,
    ! [VarCurr] :
      ( v3304(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v3302(VarCurr,B)
          <=> b01(B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_85,axiom,
    ! [VarCurr] :
      ( ~ v252(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v3305(VarCurr,B)
          <=> $false ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_87,axiom,
    ! [VarCurr] :
      ( v252(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v3305(VarCurr,B)
          <=> b10(B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_637,axiom,
    ! [VarCurr] :
      ( v3304(VarCurr)
    <=> ( v610(VarCurr)
        | v1066(VarCurr) ) ) ).

fof(addAssignment_812,axiom,
    ! [VarCurr] :
      ( v3287(VarCurr)
    <=> v3289(VarCurr) ) ).

fof(addAssignment_811,axiom,
    ! [VarCurr] :
      ( v3289(VarCurr)
    <=> v3291(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_636,axiom,
    ! [VarCurr] :
      ( v3291(VarCurr)
    <=> ( v3293(VarCurr)
        | v250(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_635,axiom,
    ! [VarCurr] :
      ( v3293(VarCurr)
    <=> ( v3294(VarCurr)
        | v608(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_634,axiom,
    ! [VarCurr] :
      ( v3294(VarCurr)
    <=> ( v108(VarCurr)
        | v508(VarCurr) ) ) ).

fof(addAssignment_810,axiom,
    ! [VarCurr] :
      ( v3285(VarCurr)
    <=> v104(VarCurr) ) ).

fof(addAssignment_809,axiom,
    ! [VarCurr] :
      ( v3207(VarCurr)
    <=> v3209(VarCurr,bitIndex3) ) ).

fof(addAssignment_808,axiom,
    ! [VarCurr] :
      ( v3209(VarCurr,bitIndex3)
    <=> v3224(VarCurr,bitIndex3) ) ).

fof(addAssignment_807,axiom,
    ! [VarNext] :
      ( v2244(VarNext,bitIndex2)
    <=> v3257(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_57,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3258(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v3257(VarNext,B)
            <=> v2244(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_70,axiom,
    ! [VarNext] :
      ( v3258(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v3257(VarNext,B)
          <=> v3221(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_633,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3258(VarNext)
      <=> v3259(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_632,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3259(VarNext)
      <=> ( v3261(VarNext)
          & v166(VarNext) ) ) ) ).

fof(writeUnaryOperator_272,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3261(VarNext)
      <=> v179(VarNext) ) ) ).

fof(addAssignment_806,axiom,
    ! [VarCurr] :
      ( v3209(VarCurr,bitIndex2)
    <=> v3224(VarCurr,bitIndex2) ) ).

fof(addAssignment_805,axiom,
    ! [VarNext] :
      ( v2244(VarNext,bitIndex1)
    <=> v3249(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_56,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3250(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v3249(VarNext,B)
            <=> v2244(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_69,axiom,
    ! [VarNext] :
      ( v3250(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v3249(VarNext,B)
          <=> v3221(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_631,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3250(VarNext)
      <=> v3251(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_630,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3251(VarNext)
      <=> ( v3253(VarNext)
          & v166(VarNext) ) ) ) ).

fof(writeUnaryOperator_271,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3253(VarNext)
      <=> v179(VarNext) ) ) ).

fof(addAssignment_804,axiom,
    ! [VarCurr] :
      ( v3209(VarCurr,bitIndex1)
    <=> v3224(VarCurr,bitIndex1) ) ).

fof(addAssignment_803,axiom,
    ! [VarNext] :
      ( v2244(VarNext,bitIndex0)
    <=> v3241(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_55,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3242(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v3241(VarNext,B)
            <=> v2244(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_68,axiom,
    ! [VarNext] :
      ( v3242(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v3241(VarNext,B)
          <=> v3221(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_629,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3242(VarNext)
      <=> v3243(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_628,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3243(VarNext)
      <=> ( v3245(VarNext)
          & v166(VarNext) ) ) ) ).

fof(writeUnaryOperator_270,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3245(VarNext)
      <=> v179(VarNext) ) ) ).

fof(addAssignment_802,axiom,
    ! [VarCurr] :
      ( v3209(VarCurr,bitIndex0)
    <=> v3224(VarCurr,bitIndex0) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_84,axiom,
    ! [VarCurr] :
      ( ~ v3225(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3224(VarCurr,B)
          <=> v3227(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_86,axiom,
    ! [VarCurr] :
      ( v3225(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3224(VarCurr,B)
          <=> v3226(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_13,axiom,
    ! [VarCurr] :
      ( ( ~ v3228(VarCurr)
        & ~ v3230(VarCurr)
        & ~ v3234(VarCurr) )
     => ! [B] :
          ( range_6_0(B)
         => ( v3227(VarCurr,B)
          <=> v2244(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_16,axiom,
    ! [VarCurr] :
      ( v3234(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3227(VarCurr,B)
          <=> v3236(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_28,axiom,
    ! [VarCurr] :
      ( v3230(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3227(VarCurr,B)
          <=> v3232(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_28,axiom,
    ! [VarCurr] :
      ( v3228(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3227(VarCurr,B)
          <=> v2244(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_163,axiom,
    ! [VarCurr] :
      ( v3238(VarCurr)
    <=> ( ( v3239(VarCurr,bitIndex1)
        <=> $true )
        & ( v3239(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_801,axiom,
    ! [VarCurr] :
      ( v3239(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_800,axiom,
    ! [VarCurr] :
      ( v3239(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(addAssignment_799,axiom,
    ! [VarCurr] :
      ( v3236(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_798,axiom,
    ! [VarCurr] :
      ( ( v3236(VarCurr,bitIndex6)
      <=> v2244(VarCurr,bitIndex5) )
      & ( v3236(VarCurr,bitIndex5)
      <=> v2244(VarCurr,bitIndex4) )
      & ( v3236(VarCurr,bitIndex4)
      <=> v2244(VarCurr,bitIndex3) )
      & ( v3236(VarCurr,bitIndex3)
      <=> v2244(VarCurr,bitIndex2) )
      & ( v3236(VarCurr,bitIndex2)
      <=> v2244(VarCurr,bitIndex1) )
      & ( v3236(VarCurr,bitIndex1)
      <=> v2244(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_162,axiom,
    ! [VarCurr] :
      ( v3234(VarCurr)
    <=> ( ( v3235(VarCurr,bitIndex1)
        <=> $true )
        & ( v3235(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_797,axiom,
    ! [VarCurr] :
      ( v3235(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_796,axiom,
    ! [VarCurr] :
      ( v3235(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(addAssignment_795,axiom,
    ! [VarCurr] :
      ( ( v3232(VarCurr,bitIndex5)
      <=> v2244(VarCurr,bitIndex6) )
      & ( v3232(VarCurr,bitIndex4)
      <=> v2244(VarCurr,bitIndex5) )
      & ( v3232(VarCurr,bitIndex3)
      <=> v2244(VarCurr,bitIndex4) )
      & ( v3232(VarCurr,bitIndex2)
      <=> v2244(VarCurr,bitIndex3) )
      & ( v3232(VarCurr,bitIndex1)
      <=> v2244(VarCurr,bitIndex2) )
      & ( v3232(VarCurr,bitIndex0)
      <=> v2244(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_794,axiom,
    ! [VarCurr] :
      ( v3232(VarCurr,bitIndex6)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_161,axiom,
    ! [VarCurr] :
      ( v3230(VarCurr)
    <=> ( ( v3231(VarCurr,bitIndex1)
        <=> $false )
        & ( v3231(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_793,axiom,
    ! [VarCurr] :
      ( v3231(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_792,axiom,
    ! [VarCurr] :
      ( v3231(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_160,axiom,
    ! [VarCurr] :
      ( v3228(VarCurr)
    <=> ( ( v3229(VarCurr,bitIndex1)
        <=> $false )
        & ( v3229(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_791,axiom,
    ! [VarCurr] :
      ( v3229(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_790,axiom,
    ! [VarCurr] :
      ( v3229(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(addAssignment_789,axiom,
    ! [VarCurr] :
      ( v3226(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_788,axiom,
    ! [VarCurr,B] :
      ( range_6_1(B)
     => ( v3226(VarCurr,B)
      <=> v2242(VarCurr,B) ) ) ).

fof(writeUnaryOperator_269,axiom,
    ! [VarCurr] :
      ( ~ v3225(VarCurr)
    <=> v82(VarCurr) ) ).

fof(addAssignment_787,axiom,
    ! [VarCurr] :
      ( v2242(VarCurr,bitIndex1)
    <=> v2243(VarCurr,bitIndex1) ) ).

fof(addAssignment_786,axiom,
    ! [VarCurr] :
      ( v2242(VarCurr,bitIndex2)
    <=> v2243(VarCurr,bitIndex2) ) ).

fof(addAssignment_785,axiom,
    ! [VarCurr] :
      ( v2242(VarCurr,bitIndex3)
    <=> v2243(VarCurr,bitIndex3) ) ).

fof(addAssignment_784,axiom,
    ! [VarNext] :
      ( v2244(VarNext,bitIndex3)
    <=> v3212(VarNext,bitIndex3) ) ).

fof(addCaseBooleanConditionEqualRanges1_54,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3213(VarNext)
       => ! [B] :
            ( range_6_0(B)
           => ( v3212(VarNext,B)
            <=> v2244(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_67,axiom,
    ! [VarNext] :
      ( v3213(VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v3212(VarNext,B)
          <=> v3221(VarNext,B) ) ) ) ).

fof(addAssignment_783,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_6_0(B)
         => ( v3221(VarNext,B)
          <=> v3219(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_83,axiom,
    ! [VarCurr] :
      ( ~ v186(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3219(VarCurr,B)
          <=> v3209(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_85,axiom,
    ! [VarCurr] :
      ( v186(VarCurr)
     => ! [B] :
          ( range_6_0(B)
         => ( v3219(VarCurr,B)
          <=> b0000001(B) ) ) ) ).

fof(range_axiom_15,axiom,
    ! [B] :
      ( range_6_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B ) ) ).

fof(bitBlastConstant_266,axiom,
    ~ b0000001(bitIndex6) ).

fof(bitBlastConstant_265,axiom,
    ~ b0000001(bitIndex5) ).

fof(bitBlastConstant_264,axiom,
    ~ b0000001(bitIndex4) ).

fof(bitBlastConstant_263,axiom,
    ~ b0000001(bitIndex3) ).

fof(bitBlastConstant_262,axiom,
    ~ b0000001(bitIndex2) ).

fof(bitBlastConstant_261,axiom,
    ~ b0000001(bitIndex1) ).

fof(bitBlastConstant_260,axiom,
    b0000001(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_627,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3213(VarNext)
      <=> v3214(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_626,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3214(VarNext)
      <=> ( v3216(VarNext)
          & v166(VarNext) ) ) ) ).

fof(writeUnaryOperator_268,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3216(VarNext)
      <=> v179(VarNext) ) ) ).

fof(addAssignment_782,axiom,
    ! [VarCurr] :
      ( v3071(VarCurr)
    <=> v3073(VarCurr,bitIndex5) ) ).

fof(addAssignment_781,axiom,
    ! [VarCurr] :
      ( v3073(VarCurr,bitIndex5)
    <=> v3106(VarCurr,bitIndex5) ) ).

fof(addAssignment_780,axiom,
    ! [VarNext] :
      ( v3077(VarNext,bitIndex4)
    <=> v3155(VarNext,bitIndex4) ) ).

fof(addCaseBooleanConditionEqualRanges1_53,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3156(VarNext)
       => ! [B] :
            ( range_10_0(B)
           => ( v3155(VarNext,B)
            <=> v3077(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_66,axiom,
    ! [VarNext] :
      ( v3156(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v3155(VarNext,B)
          <=> v3101(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_625,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3156(VarNext)
      <=> v3157(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_624,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3157(VarNext)
      <=> ( v3159(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_267,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3159(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_779,axiom,
    ! [VarCurr] :
      ( v3073(VarCurr,bitIndex4)
    <=> v3106(VarCurr,bitIndex4) ) ).

fof(addAssignment_778,axiom,
    ! [VarNext] :
      ( v3077(VarNext,bitIndex3)
    <=> v3147(VarNext,bitIndex3) ) ).

fof(addCaseBooleanConditionEqualRanges1_52,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3148(VarNext)
       => ! [B] :
            ( range_10_0(B)
           => ( v3147(VarNext,B)
            <=> v3077(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_65,axiom,
    ! [VarNext] :
      ( v3148(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v3147(VarNext,B)
          <=> v3101(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_623,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3148(VarNext)
      <=> v3149(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_622,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3149(VarNext)
      <=> ( v3151(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_266,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3151(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_777,axiom,
    ! [VarCurr] :
      ( v3073(VarCurr,bitIndex3)
    <=> v3106(VarCurr,bitIndex3) ) ).

fof(addAssignment_776,axiom,
    ! [VarNext] :
      ( v3077(VarNext,bitIndex2)
    <=> v3139(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_51,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3140(VarNext)
       => ! [B] :
            ( range_10_0(B)
           => ( v3139(VarNext,B)
            <=> v3077(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_64,axiom,
    ! [VarNext] :
      ( v3140(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v3139(VarNext,B)
          <=> v3101(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_621,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3140(VarNext)
      <=> v3141(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_620,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3141(VarNext)
      <=> ( v3143(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_265,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3143(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_775,axiom,
    ! [VarCurr] :
      ( v3073(VarCurr,bitIndex2)
    <=> v3106(VarCurr,bitIndex2) ) ).

fof(addAssignment_774,axiom,
    ! [VarNext] :
      ( v3077(VarNext,bitIndex1)
    <=> v3131(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_50,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3132(VarNext)
       => ! [B] :
            ( range_10_0(B)
           => ( v3131(VarNext,B)
            <=> v3077(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_63,axiom,
    ! [VarNext] :
      ( v3132(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v3131(VarNext,B)
          <=> v3101(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_619,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3132(VarNext)
      <=> v3133(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_618,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3133(VarNext)
      <=> ( v3135(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_264,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3135(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_773,axiom,
    ! [VarCurr] :
      ( v3073(VarCurr,bitIndex1)
    <=> v3106(VarCurr,bitIndex1) ) ).

fof(addAssignment_772,axiom,
    ! [VarNext] :
      ( v3077(VarNext,bitIndex0)
    <=> v3123(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_49,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3124(VarNext)
       => ! [B] :
            ( range_10_0(B)
           => ( v3123(VarNext,B)
            <=> v3077(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_62,axiom,
    ! [VarNext] :
      ( v3124(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v3123(VarNext,B)
          <=> v3101(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_617,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3124(VarNext)
      <=> v3125(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_616,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3125(VarNext)
      <=> ( v3127(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_263,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3127(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_771,axiom,
    ! [VarCurr] :
      ( v3073(VarCurr,bitIndex0)
    <=> v3106(VarCurr,bitIndex0) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_82,axiom,
    ! [VarCurr] :
      ( ~ v3107(VarCurr)
     => ! [B] :
          ( range_10_0(B)
         => ( v3106(VarCurr,B)
          <=> v3109(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_84,axiom,
    ! [VarCurr] :
      ( v3107(VarCurr)
     => ! [B] :
          ( range_10_0(B)
         => ( v3106(VarCurr,B)
          <=> v3108(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_12,axiom,
    ! [VarCurr] :
      ( ( ~ v3110(VarCurr)
        & ~ v3112(VarCurr)
        & ~ v3116(VarCurr) )
     => ! [B] :
          ( range_10_0(B)
         => ( v3109(VarCurr,B)
          <=> v3077(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_15,axiom,
    ! [VarCurr] :
      ( v3116(VarCurr)
     => ! [B] :
          ( range_10_0(B)
         => ( v3109(VarCurr,B)
          <=> v3118(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_27,axiom,
    ! [VarCurr] :
      ( v3112(VarCurr)
     => ! [B] :
          ( range_10_0(B)
         => ( v3109(VarCurr,B)
          <=> v3114(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_27,axiom,
    ! [VarCurr] :
      ( v3110(VarCurr)
     => ! [B] :
          ( range_10_0(B)
         => ( v3109(VarCurr,B)
          <=> v3077(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_159,axiom,
    ! [VarCurr] :
      ( v3120(VarCurr)
    <=> ( ( v3121(VarCurr,bitIndex1)
        <=> $true )
        & ( v3121(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_770,axiom,
    ! [VarCurr] :
      ( v3121(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_769,axiom,
    ! [VarCurr] :
      ( v3121(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(addAssignment_768,axiom,
    ! [VarCurr] :
      ( v3118(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_767,axiom,
    ! [VarCurr] :
      ( ( v3118(VarCurr,bitIndex10)
      <=> v3077(VarCurr,bitIndex9) )
      & ( v3118(VarCurr,bitIndex9)
      <=> v3077(VarCurr,bitIndex8) )
      & ( v3118(VarCurr,bitIndex8)
      <=> v3077(VarCurr,bitIndex7) )
      & ( v3118(VarCurr,bitIndex7)
      <=> v3077(VarCurr,bitIndex6) )
      & ( v3118(VarCurr,bitIndex6)
      <=> v3077(VarCurr,bitIndex5) )
      & ( v3118(VarCurr,bitIndex5)
      <=> v3077(VarCurr,bitIndex4) )
      & ( v3118(VarCurr,bitIndex4)
      <=> v3077(VarCurr,bitIndex3) )
      & ( v3118(VarCurr,bitIndex3)
      <=> v3077(VarCurr,bitIndex2) )
      & ( v3118(VarCurr,bitIndex2)
      <=> v3077(VarCurr,bitIndex1) )
      & ( v3118(VarCurr,bitIndex1)
      <=> v3077(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_158,axiom,
    ! [VarCurr] :
      ( v3116(VarCurr)
    <=> ( ( v3117(VarCurr,bitIndex1)
        <=> $true )
        & ( v3117(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_766,axiom,
    ! [VarCurr] :
      ( v3117(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_765,axiom,
    ! [VarCurr] :
      ( v3117(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(addAssignment_764,axiom,
    ! [VarCurr] :
      ( ( v3114(VarCurr,bitIndex9)
      <=> v3077(VarCurr,bitIndex10) )
      & ( v3114(VarCurr,bitIndex8)
      <=> v3077(VarCurr,bitIndex9) )
      & ( v3114(VarCurr,bitIndex7)
      <=> v3077(VarCurr,bitIndex8) )
      & ( v3114(VarCurr,bitIndex6)
      <=> v3077(VarCurr,bitIndex7) )
      & ( v3114(VarCurr,bitIndex5)
      <=> v3077(VarCurr,bitIndex6) )
      & ( v3114(VarCurr,bitIndex4)
      <=> v3077(VarCurr,bitIndex5) )
      & ( v3114(VarCurr,bitIndex3)
      <=> v3077(VarCurr,bitIndex4) )
      & ( v3114(VarCurr,bitIndex2)
      <=> v3077(VarCurr,bitIndex3) )
      & ( v3114(VarCurr,bitIndex1)
      <=> v3077(VarCurr,bitIndex2) )
      & ( v3114(VarCurr,bitIndex0)
      <=> v3077(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_763,axiom,
    ! [VarCurr] :
      ( v3114(VarCurr,bitIndex10)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_157,axiom,
    ! [VarCurr] :
      ( v3112(VarCurr)
    <=> ( ( v3113(VarCurr,bitIndex1)
        <=> $false )
        & ( v3113(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_762,axiom,
    ! [VarCurr] :
      ( v3113(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_761,axiom,
    ! [VarCurr] :
      ( v3113(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_156,axiom,
    ! [VarCurr] :
      ( v3110(VarCurr)
    <=> ( ( v3111(VarCurr,bitIndex1)
        <=> $false )
        & ( v3111(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_760,axiom,
    ! [VarCurr] :
      ( v3111(VarCurr,bitIndex0)
    <=> v2980(VarCurr) ) ).

fof(addAssignment_759,axiom,
    ! [VarCurr] :
      ( v3111(VarCurr,bitIndex1)
    <=> v37(VarCurr) ) ).

fof(addAssignment_758,axiom,
    ! [VarCurr] :
      ( v3108(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_757,axiom,
    ! [VarCurr,B] :
      ( range_10_1(B)
     => ( v3108(VarCurr,B)
      <=> v3075(VarCurr,B) ) ) ).

fof(writeUnaryOperator_262,axiom,
    ! [VarCurr] :
      ( ~ v3107(VarCurr)
    <=> v33(VarCurr) ) ).

fof(addAssignment_756,axiom,
    ! [VarCurr] :
      ( v3075(VarCurr,bitIndex1)
    <=> v3105(VarCurr,bitIndex1) ) ).

fof(addAssignment_755,axiom,
    ! [VarCurr] :
      ( v3075(VarCurr,bitIndex2)
    <=> v3105(VarCurr,bitIndex2) ) ).

fof(addAssignment_754,axiom,
    ! [VarCurr] :
      ( v3075(VarCurr,bitIndex3)
    <=> v3105(VarCurr,bitIndex3) ) ).

fof(addAssignment_753,axiom,
    ! [VarCurr] :
      ( v3075(VarCurr,bitIndex4)
    <=> v3105(VarCurr,bitIndex4) ) ).

fof(addAssignment_752,axiom,
    ! [VarCurr] :
      ( v3075(VarCurr,bitIndex5)
    <=> v3105(VarCurr,bitIndex5) ) ).

fof(addAssignment_751,axiom,
    ! [VarCurr] :
      ( v3105(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_750,axiom,
    ! [VarCurr,B] :
      ( range_10_1(B)
     => ( v3105(VarCurr,B)
      <=> v3077(VarCurr,B) ) ) ).

fof(range_axiom_14,axiom,
    ! [B] :
      ( range_10_1(B)
    <=> ( $false
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B ) ) ).

fof(addAssignment_749,axiom,
    ! [VarNext] :
      ( v3077(VarNext,bitIndex5)
    <=> v3090(VarNext,bitIndex5) ) ).

fof(addCaseBooleanConditionEqualRanges1_48,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3091(VarNext)
       => ! [B] :
            ( range_10_0(B)
           => ( v3090(VarNext,B)
            <=> v3077(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_61,axiom,
    ! [VarNext] :
      ( v3091(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v3090(VarNext,B)
          <=> v3101(VarNext,B) ) ) ) ).

fof(addAssignment_748,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v3101(VarNext,B)
          <=> v3099(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_81,axiom,
    ! [VarCurr] :
      ( ~ v3102(VarCurr)
     => ! [B] :
          ( range_10_0(B)
         => ( v3099(VarCurr,B)
          <=> v3073(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_83,axiom,
    ! [VarCurr] :
      ( v3102(VarCurr)
     => ! [B] :
          ( range_10_0(B)
         => ( v3099(VarCurr,B)
          <=> b00000000001(B) ) ) ) ).

fof(bitBlastConstant_259,axiom,
    ~ b00000000001(bitIndex10) ).

fof(bitBlastConstant_258,axiom,
    ~ b00000000001(bitIndex9) ).

fof(bitBlastConstant_257,axiom,
    ~ b00000000001(bitIndex8) ).

fof(bitBlastConstant_256,axiom,
    ~ b00000000001(bitIndex7) ).

fof(bitBlastConstant_255,axiom,
    ~ b00000000001(bitIndex6) ).

fof(bitBlastConstant_254,axiom,
    ~ b00000000001(bitIndex5) ).

fof(bitBlastConstant_253,axiom,
    ~ b00000000001(bitIndex4) ).

fof(bitBlastConstant_252,axiom,
    ~ b00000000001(bitIndex3) ).

fof(bitBlastConstant_251,axiom,
    ~ b00000000001(bitIndex2) ).

fof(bitBlastConstant_250,axiom,
    ~ b00000000001(bitIndex1) ).

fof(bitBlastConstant_249,axiom,
    b00000000001(bitIndex0) ).

fof(writeUnaryOperator_261,axiom,
    ! [VarCurr] :
      ( ~ v3102(VarCurr)
    <=> v33(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_615,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3091(VarNext)
      <=> v3092(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_614,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3092(VarNext)
      <=> ( v3093(VarNext)
          & v3080(VarNext) ) ) ) ).

fof(writeUnaryOperator_260,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v3093(VarNext)
      <=> v3095(VarNext) ) ) ).

fof(addAssignment_747,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v3095(VarNext)
      <=> v3080(VarCurr) ) ) ).

fof(addAssignmentInitValue_18,axiom,
    ~ v3077(constB0,bitIndex4) ).

fof(addAssignmentInitValue_17,axiom,
    ~ v3077(constB0,bitIndex3) ).

fof(addAssignmentInitValue_16,axiom,
    ~ v3077(constB0,bitIndex2) ).

fof(addAssignmentInitValue_15,axiom,
    ~ v3077(constB0,bitIndex1) ).

fof(addAssignmentInitValue_14,axiom,
    v3077(constB0,bitIndex0) ).

fof(bitBlastConstant_248,axiom,
    ~ bxxxxxx00001(bitIndex4) ).

fof(bitBlastConstant_247,axiom,
    ~ bxxxxxx00001(bitIndex3) ).

fof(bitBlastConstant_246,axiom,
    ~ bxxxxxx00001(bitIndex2) ).

fof(bitBlastConstant_245,axiom,
    ~ bxxxxxx00001(bitIndex1) ).

fof(bitBlastConstant_244,axiom,
    bxxxxxx00001(bitIndex0) ).

fof(addAssignment_746,axiom,
    ! [VarCurr] :
      ( v3080(VarCurr)
    <=> v3082(VarCurr) ) ).

fof(addAssignment_745,axiom,
    ! [VarCurr] :
      ( v3082(VarCurr)
    <=> v3084(VarCurr) ) ).

fof(addAssignment_744,axiom,
    ! [VarCurr] :
      ( v3084(VarCurr)
    <=> v3086(VarCurr) ) ).

fof(addAssignment_743,axiom,
    ! [VarCurr] :
      ( v3086(VarCurr)
    <=> v1(VarCurr) ) ).

fof(addAssignment_742,axiom,
    ! [VarCurr] :
      ( v3030(VarCurr)
    <=> v3032(VarCurr) ) ).

fof(addAssignment_741,axiom,
    ! [VarCurr] :
      ( v3032(VarCurr)
    <=> v14(VarCurr) ) ).

fof(addAssignment_740,axiom,
    ! [VarCurr] :
      ( v3006(VarCurr)
    <=> v3008(VarCurr) ) ).

fof(addAssignment_739,axiom,
    ! [VarCurr] :
      ( v3008(VarCurr)
    <=> v3010(VarCurr) ) ).

fof(addAssignment_738,axiom,
    ! [VarCurr] :
      ( v3010(VarCurr)
    <=> v6(VarCurr,bitIndex0) ) ).

fof(addAssignmentInitValueVector_10,axiom,
    ( ( v6(constB0,bitIndex3)
    <=> $false )
    & ( v6(constB0,bitIndex2)
    <=> $false )
    & ( v6(constB0,bitIndex1)
    <=> $false ) ) ).

fof(bitBlastConstant_243,axiom,
    ~ b000(bitIndex2) ).

fof(bitBlastConstant_242,axiom,
    ~ b000(bitIndex1) ).

fof(bitBlastConstant_241,axiom,
    ~ b000(bitIndex0) ).

fof(addAssignmentInitValueVector_9,axiom,
    ( v6(constB0,bitIndex0)
  <=> $true ) ).

fof(addAssignment_737,axiom,
    ! [VarCurr] :
      ( v2996(VarCurr)
    <=> v2998(VarCurr) ) ).

fof(addAssignment_736,axiom,
    ! [VarCurr] :
      ( v2998(VarCurr)
    <=> v3000(VarCurr) ) ).

fof(addAssignment_735,axiom,
    ! [VarCurr] :
      ( v3000(VarCurr)
    <=> v3002(VarCurr) ) ).

fof(addAssignment_734,axiom,
    ! [VarCurr] :
      ( v74(VarCurr)
    <=> v76(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_613,axiom,
    ! [VarCurr] :
      ( v76(VarCurr)
    <=> ( v2954(VarCurr)
        & v2857(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_612,axiom,
    ! [VarCurr] :
      ( v2954(VarCurr)
    <=> ( v2955(VarCurr)
        & v2760(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_611,axiom,
    ! [VarCurr] :
      ( v2955(VarCurr)
    <=> ( v2956(VarCurr)
        & v2663(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_610,axiom,
    ! [VarCurr] :
      ( v2956(VarCurr)
    <=> ( v2957(VarCurr)
        & v2566(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_609,axiom,
    ! [VarCurr] :
      ( v2957(VarCurr)
    <=> ( v2958(VarCurr)
        & v2469(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_608,axiom,
    ! [VarCurr] :
      ( v2958(VarCurr)
    <=> ( v2959(VarCurr)
        & v2370(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_607,axiom,
    ! [VarCurr] :
      ( v2959(VarCurr)
    <=> ( v78(VarCurr)
        & v2273(VarCurr) ) ) ).

fof(addAssignment_733,axiom,
    ! [VarCurr] :
      ( v2857(VarCurr)
    <=> v2859(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_47,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2931(VarNext)
       => ( v2859(VarNext)
        <=> v2859(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_60,axiom,
    ! [VarNext] :
      ( v2931(VarNext)
     => ( v2859(VarNext)
      <=> v2949(VarNext) ) ) ).

fof(addAssignment_732,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2949(VarNext)
      <=> v2947(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_80,axiom,
    ! [VarCurr] :
      ( ~ v2946(VarCurr)
     => ( v2947(VarCurr)
      <=> v2950(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_82,axiom,
    ! [VarCurr] :
      ( v2946(VarCurr)
     => ( v2947(VarCurr)
      <=> $true ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_79,axiom,
    ! [VarCurr] :
      ( ~ v2863(VarCurr)
     => ( v2950(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_81,axiom,
    ! [VarCurr] :
      ( v2863(VarCurr)
     => ( v2950(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_606,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2931(VarNext)
      <=> ( v2932(VarNext)
          & v2939(VarNext) ) ) ) ).

fof(addAssignment_731,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2939(VarNext)
      <=> v2937(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_605,axiom,
    ! [VarCurr] :
      ( v2937(VarCurr)
    <=> ( v2940(VarCurr)
        | v2946(VarCurr) ) ) ).

fof(writeUnaryOperator_259,axiom,
    ! [VarCurr] :
      ( ~ v2946(VarCurr)
    <=> v2861(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_604,axiom,
    ! [VarCurr] :
      ( v2940(VarCurr)
    <=> ( v2941(VarCurr)
        | v2863(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_603,axiom,
    ! [VarCurr] :
      ( v2941(VarCurr)
    <=> ( v2942(VarCurr)
        & v2945(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_155,axiom,
    ! [VarCurr] :
      ( v2945(VarCurr)
    <=> ( v2925(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_602,axiom,
    ! [VarCurr] :
      ( v2942(VarCurr)
    <=> ( v2943(VarCurr)
        & v2944(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_154,axiom,
    ! [VarCurr] :
      ( v2944(VarCurr)
    <=> ( v2867(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_153,axiom,
    ! [VarCurr] :
      ( v2943(VarCurr)
    <=> ( v2865(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_601,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2932(VarNext)
      <=> ( v2933(VarNext)
          & v2891(VarNext) ) ) ) ).

fof(writeUnaryOperator_258,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2933(VarNext)
      <=> v2898(VarNext) ) ) ).

fof(addAssignmentInitValueVector_8,axiom,
    ( v2859(constB0)
  <=> $true ) ).

fof(addAssignment_730,axiom,
    ! [VarCurr] :
      ( v2925(VarCurr,bitIndex0)
    <=> v2926(VarCurr,bitIndex0) ) ).

fof(addAssignment_729,axiom,
    ! [VarCurr] :
      ( v2926(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_728,axiom,
    ! [VarCurr,B] :
      ( range_6_1(B)
     => ( v2926(VarCurr,B)
      <=> v2927(VarCurr,B) ) ) ).

fof(addAssignment_727,axiom,
    ! [VarNext] :
      ( v2867(VarNext,bitIndex1)
    <=> v2917(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_46,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2918(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2917(VarNext,B)
            <=> v2867(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_59,axiom,
    ! [VarNext] :
      ( v2918(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2917(VarNext,B)
          <=> v2904(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_600,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2918(VarNext)
      <=> v2919(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_599,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2919(VarNext)
      <=> ( v2921(VarNext)
          & v2891(VarNext) ) ) ) ).

fof(writeUnaryOperator_257,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2921(VarNext)
      <=> v2898(VarNext) ) ) ).

fof(addAssignment_726,axiom,
    ! [VarCurr] :
      ( v2869(VarCurr,bitIndex1)
    <=> v2876(VarCurr,bitIndex1) ) ).

fof(addAssignment_725,axiom,
    ! [VarCurr] :
      ( v2871(VarCurr,bitIndex1)
    <=> v2872(VarCurr,bitIndex1) ) ).

fof(addAssignment_724,axiom,
    ! [VarNext] :
      ( v2867(VarNext,bitIndex0)
    <=> v2909(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_45,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2910(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2909(VarNext,B)
            <=> v2867(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_58,axiom,
    ! [VarNext] :
      ( v2910(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2909(VarNext,B)
          <=> v2904(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_598,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2910(VarNext)
      <=> v2911(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_597,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2911(VarNext)
      <=> ( v2913(VarNext)
          & v2891(VarNext) ) ) ) ).

fof(writeUnaryOperator_256,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2913(VarNext)
      <=> v2898(VarNext) ) ) ).

fof(addAssignment_723,axiom,
    ! [VarCurr] :
      ( v2869(VarCurr,bitIndex0)
    <=> v2876(VarCurr,bitIndex0) ) ).

fof(addAssignment_722,axiom,
    ! [VarNext] :
      ( v2867(VarNext,bitIndex2)
    <=> v2893(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_44,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2894(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2893(VarNext,B)
            <=> v2867(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_57,axiom,
    ! [VarNext] :
      ( v2894(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2893(VarNext,B)
          <=> v2904(VarNext,B) ) ) ) ).

fof(addAssignment_721,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2904(VarNext,B)
          <=> v2902(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_78,axiom,
    ! [VarCurr] :
      ( ~ v2905(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2902(VarCurr,B)
          <=> v2869(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_80,axiom,
    ! [VarCurr] :
      ( v2905(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2902(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_255,axiom,
    ! [VarCurr] :
      ( ~ v2905(VarCurr)
    <=> v2861(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_596,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2894(VarNext)
      <=> v2895(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_595,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2895(VarNext)
      <=> ( v2896(VarNext)
          & v2891(VarNext) ) ) ) ).

fof(writeUnaryOperator_254,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2896(VarNext)
      <=> v2898(VarNext) ) ) ).

fof(addAssignment_720,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2898(VarNext)
      <=> v2891(VarCurr) ) ) ).

fof(addAssignment_719,axiom,
    ! [VarCurr] :
      ( v2891(VarCurr)
    <=> v168(VarCurr) ) ).

fof(addAssignment_718,axiom,
    ! [VarCurr] :
      ( v2869(VarCurr,bitIndex2)
    <=> v2876(VarCurr,bitIndex2) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_77,axiom,
    ! [VarCurr] :
      ( ~ v2877(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2876(VarCurr,B)
          <=> v2878(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_79,axiom,
    ! [VarCurr] :
      ( v2877(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2876(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_11,axiom,
    ! [VarCurr] :
      ( ( ~ v2879(VarCurr)
        & ~ v2881(VarCurr)
        & ~ v2885(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v2878(VarCurr,B)
          <=> v2867(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_14,axiom,
    ! [VarCurr] :
      ( v2885(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2878(VarCurr,B)
          <=> v2887(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_26,axiom,
    ! [VarCurr] :
      ( v2881(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2878(VarCurr,B)
          <=> v2883(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_26,axiom,
    ! [VarCurr] :
      ( v2879(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2878(VarCurr,B)
          <=> v2867(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_152,axiom,
    ! [VarCurr] :
      ( v2888(VarCurr)
    <=> ( ( v2889(VarCurr,bitIndex1)
        <=> $true )
        & ( v2889(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_717,axiom,
    ! [VarCurr] :
      ( v2889(VarCurr,bitIndex0)
    <=> v2865(VarCurr) ) ).

fof(addAssignment_716,axiom,
    ! [VarCurr] :
      ( v2889(VarCurr,bitIndex1)
    <=> v2863(VarCurr) ) ).

fof(addAssignment_715,axiom,
    ! [VarCurr] :
      ( v2887(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_714,axiom,
    ! [VarCurr,B] :
      ( range_3_1(B)
     => ( v2887(VarCurr,B)
      <=> v2871(VarCurr,B) ) ) ).

fof(addBitVectorEqualityBitBlasted_151,axiom,
    ! [VarCurr] :
      ( v2885(VarCurr)
    <=> ( ( v2886(VarCurr,bitIndex1)
        <=> $true )
        & ( v2886(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_713,axiom,
    ! [VarCurr] :
      ( v2886(VarCurr,bitIndex0)
    <=> v2865(VarCurr) ) ).

fof(addAssignment_712,axiom,
    ! [VarCurr] :
      ( v2886(VarCurr,bitIndex1)
    <=> v2863(VarCurr) ) ).

fof(addAssignment_711,axiom,
    ! [VarCurr] :
      ( ( v2883(VarCurr,bitIndex2)
      <=> v2867(VarCurr,bitIndex3) )
      & ( v2883(VarCurr,bitIndex1)
      <=> v2867(VarCurr,bitIndex2) )
      & ( v2883(VarCurr,bitIndex0)
      <=> v2867(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_710,axiom,
    ! [VarCurr] :
      ( v2883(VarCurr,bitIndex3)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_150,axiom,
    ! [VarCurr] :
      ( v2881(VarCurr)
    <=> ( ( v2882(VarCurr,bitIndex1)
        <=> $false )
        & ( v2882(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_709,axiom,
    ! [VarCurr] :
      ( v2882(VarCurr,bitIndex0)
    <=> v2865(VarCurr) ) ).

fof(addAssignment_708,axiom,
    ! [VarCurr] :
      ( v2882(VarCurr,bitIndex1)
    <=> v2863(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_149,axiom,
    ! [VarCurr] :
      ( v2879(VarCurr)
    <=> ( ( v2880(VarCurr,bitIndex1)
        <=> $false )
        & ( v2880(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_707,axiom,
    ! [VarCurr] :
      ( v2880(VarCurr,bitIndex0)
    <=> v2865(VarCurr) ) ).

fof(addAssignment_706,axiom,
    ! [VarCurr] :
      ( v2880(VarCurr,bitIndex1)
    <=> v2863(VarCurr) ) ).

fof(writeUnaryOperator_253,axiom,
    ! [VarCurr] :
      ( ~ v2877(VarCurr)
    <=> v2861(VarCurr) ) ).

fof(addAssignment_705,axiom,
    ! [VarCurr] :
      ( v2871(VarCurr,bitIndex2)
    <=> v2872(VarCurr,bitIndex2) ) ).

fof(addAssignment_704,axiom,
    ! [VarCurr] :
      ( v2872(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_703,axiom,
    ! [VarCurr] :
      ( ( v2872(VarCurr,bitIndex3)
      <=> v2867(VarCurr,bitIndex2) )
      & ( v2872(VarCurr,bitIndex2)
      <=> v2867(VarCurr,bitIndex1) )
      & ( v2872(VarCurr,bitIndex1)
      <=> v2867(VarCurr,bitIndex0) ) ) ).

fof(addAssignmentInitValue_13,axiom,
    ~ v2867(constB0,bitIndex1) ).

fof(bitBlastConstant_240,axiom,
    ~ bxx0x(bitIndex1) ).

fof(addAssignment_702,axiom,
    ! [VarCurr] :
      ( v2865(VarCurr)
    <=> v137(VarCurr) ) ).

fof(addAssignment_701,axiom,
    ! [VarCurr] :
      ( v2863(VarCurr)
    <=> v88(VarCurr) ) ).

fof(addAssignment_700,axiom,
    ! [VarCurr] :
      ( v2861(VarCurr)
    <=> v84(VarCurr) ) ).

fof(addAssignment_699,axiom,
    ! [VarCurr] :
      ( v2760(VarCurr)
    <=> v2762(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_43,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2834(VarNext)
       => ( v2762(VarNext)
        <=> v2762(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_56,axiom,
    ! [VarNext] :
      ( v2834(VarNext)
     => ( v2762(VarNext)
      <=> v2852(VarNext) ) ) ).

fof(addAssignment_698,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2852(VarNext)
      <=> v2850(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_76,axiom,
    ! [VarCurr] :
      ( ~ v2849(VarCurr)
     => ( v2850(VarCurr)
      <=> v2853(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_78,axiom,
    ! [VarCurr] :
      ( v2849(VarCurr)
     => ( v2850(VarCurr)
      <=> $true ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_75,axiom,
    ! [VarCurr] :
      ( ~ v2766(VarCurr)
     => ( v2853(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_77,axiom,
    ! [VarCurr] :
      ( v2766(VarCurr)
     => ( v2853(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_594,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2834(VarNext)
      <=> ( v2835(VarNext)
          & v2842(VarNext) ) ) ) ).

fof(addAssignment_697,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2842(VarNext)
      <=> v2840(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_593,axiom,
    ! [VarCurr] :
      ( v2840(VarCurr)
    <=> ( v2843(VarCurr)
        | v2849(VarCurr) ) ) ).

fof(writeUnaryOperator_252,axiom,
    ! [VarCurr] :
      ( ~ v2849(VarCurr)
    <=> v2764(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_592,axiom,
    ! [VarCurr] :
      ( v2843(VarCurr)
    <=> ( v2844(VarCurr)
        | v2766(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_591,axiom,
    ! [VarCurr] :
      ( v2844(VarCurr)
    <=> ( v2845(VarCurr)
        & v2848(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_148,axiom,
    ! [VarCurr] :
      ( v2848(VarCurr)
    <=> ( v2828(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_590,axiom,
    ! [VarCurr] :
      ( v2845(VarCurr)
    <=> ( v2846(VarCurr)
        & v2847(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_147,axiom,
    ! [VarCurr] :
      ( v2847(VarCurr)
    <=> ( v2770(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_146,axiom,
    ! [VarCurr] :
      ( v2846(VarCurr)
    <=> ( v2768(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_589,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2835(VarNext)
      <=> ( v2836(VarNext)
          & v2794(VarNext) ) ) ) ).

fof(writeUnaryOperator_251,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2836(VarNext)
      <=> v2801(VarNext) ) ) ).

fof(addAssignmentInitValueVector_7,axiom,
    ( v2762(constB0)
  <=> $true ) ).

fof(addAssignment_696,axiom,
    ! [VarCurr] :
      ( v2828(VarCurr,bitIndex0)
    <=> v2829(VarCurr,bitIndex0) ) ).

fof(addAssignment_695,axiom,
    ! [VarCurr] :
      ( v2829(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_694,axiom,
    ! [VarCurr,B] :
      ( range_6_1(B)
     => ( v2829(VarCurr,B)
      <=> v2830(VarCurr,B) ) ) ).

fof(addAssignment_693,axiom,
    ! [VarNext] :
      ( v2770(VarNext,bitIndex1)
    <=> v2820(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_42,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2821(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2820(VarNext,B)
            <=> v2770(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_55,axiom,
    ! [VarNext] :
      ( v2821(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2820(VarNext,B)
          <=> v2807(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_588,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2821(VarNext)
      <=> v2822(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_587,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2822(VarNext)
      <=> ( v2824(VarNext)
          & v2794(VarNext) ) ) ) ).

fof(writeUnaryOperator_250,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2824(VarNext)
      <=> v2801(VarNext) ) ) ).

fof(addAssignment_692,axiom,
    ! [VarCurr] :
      ( v2772(VarCurr,bitIndex1)
    <=> v2779(VarCurr,bitIndex1) ) ).

fof(addAssignment_691,axiom,
    ! [VarCurr] :
      ( v2774(VarCurr,bitIndex1)
    <=> v2775(VarCurr,bitIndex1) ) ).

fof(addAssignment_690,axiom,
    ! [VarNext] :
      ( v2770(VarNext,bitIndex0)
    <=> v2812(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_41,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2813(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2812(VarNext,B)
            <=> v2770(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_54,axiom,
    ! [VarNext] :
      ( v2813(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2812(VarNext,B)
          <=> v2807(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_586,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2813(VarNext)
      <=> v2814(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_585,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2814(VarNext)
      <=> ( v2816(VarNext)
          & v2794(VarNext) ) ) ) ).

fof(writeUnaryOperator_249,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2816(VarNext)
      <=> v2801(VarNext) ) ) ).

fof(addAssignment_689,axiom,
    ! [VarCurr] :
      ( v2772(VarCurr,bitIndex0)
    <=> v2779(VarCurr,bitIndex0) ) ).

fof(addAssignment_688,axiom,
    ! [VarNext] :
      ( v2770(VarNext,bitIndex2)
    <=> v2796(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_40,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2797(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2796(VarNext,B)
            <=> v2770(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_53,axiom,
    ! [VarNext] :
      ( v2797(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2796(VarNext,B)
          <=> v2807(VarNext,B) ) ) ) ).

fof(addAssignment_687,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2807(VarNext,B)
          <=> v2805(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_74,axiom,
    ! [VarCurr] :
      ( ~ v2808(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2805(VarCurr,B)
          <=> v2772(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_76,axiom,
    ! [VarCurr] :
      ( v2808(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2805(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_248,axiom,
    ! [VarCurr] :
      ( ~ v2808(VarCurr)
    <=> v2764(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_584,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2797(VarNext)
      <=> v2798(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_583,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2798(VarNext)
      <=> ( v2799(VarNext)
          & v2794(VarNext) ) ) ) ).

fof(writeUnaryOperator_247,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2799(VarNext)
      <=> v2801(VarNext) ) ) ).

fof(addAssignment_686,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2801(VarNext)
      <=> v2794(VarCurr) ) ) ).

fof(addAssignment_685,axiom,
    ! [VarCurr] :
      ( v2794(VarCurr)
    <=> v168(VarCurr) ) ).

fof(addAssignment_684,axiom,
    ! [VarCurr] :
      ( v2772(VarCurr,bitIndex2)
    <=> v2779(VarCurr,bitIndex2) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_73,axiom,
    ! [VarCurr] :
      ( ~ v2780(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2779(VarCurr,B)
          <=> v2781(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_75,axiom,
    ! [VarCurr] :
      ( v2780(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2779(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_10,axiom,
    ! [VarCurr] :
      ( ( ~ v2782(VarCurr)
        & ~ v2784(VarCurr)
        & ~ v2788(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v2781(VarCurr,B)
          <=> v2770(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_13,axiom,
    ! [VarCurr] :
      ( v2788(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2781(VarCurr,B)
          <=> v2790(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_25,axiom,
    ! [VarCurr] :
      ( v2784(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2781(VarCurr,B)
          <=> v2786(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_25,axiom,
    ! [VarCurr] :
      ( v2782(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2781(VarCurr,B)
          <=> v2770(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_145,axiom,
    ! [VarCurr] :
      ( v2791(VarCurr)
    <=> ( ( v2792(VarCurr,bitIndex1)
        <=> $true )
        & ( v2792(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_683,axiom,
    ! [VarCurr] :
      ( v2792(VarCurr,bitIndex0)
    <=> v2768(VarCurr) ) ).

fof(addAssignment_682,axiom,
    ! [VarCurr] :
      ( v2792(VarCurr,bitIndex1)
    <=> v2766(VarCurr) ) ).

fof(addAssignment_681,axiom,
    ! [VarCurr] :
      ( v2790(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_680,axiom,
    ! [VarCurr,B] :
      ( range_3_1(B)
     => ( v2790(VarCurr,B)
      <=> v2774(VarCurr,B) ) ) ).

fof(addBitVectorEqualityBitBlasted_144,axiom,
    ! [VarCurr] :
      ( v2788(VarCurr)
    <=> ( ( v2789(VarCurr,bitIndex1)
        <=> $true )
        & ( v2789(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_679,axiom,
    ! [VarCurr] :
      ( v2789(VarCurr,bitIndex0)
    <=> v2768(VarCurr) ) ).

fof(addAssignment_678,axiom,
    ! [VarCurr] :
      ( v2789(VarCurr,bitIndex1)
    <=> v2766(VarCurr) ) ).

fof(addAssignment_677,axiom,
    ! [VarCurr] :
      ( ( v2786(VarCurr,bitIndex2)
      <=> v2770(VarCurr,bitIndex3) )
      & ( v2786(VarCurr,bitIndex1)
      <=> v2770(VarCurr,bitIndex2) )
      & ( v2786(VarCurr,bitIndex0)
      <=> v2770(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_676,axiom,
    ! [VarCurr] :
      ( v2786(VarCurr,bitIndex3)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_143,axiom,
    ! [VarCurr] :
      ( v2784(VarCurr)
    <=> ( ( v2785(VarCurr,bitIndex1)
        <=> $false )
        & ( v2785(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_675,axiom,
    ! [VarCurr] :
      ( v2785(VarCurr,bitIndex0)
    <=> v2768(VarCurr) ) ).

fof(addAssignment_674,axiom,
    ! [VarCurr] :
      ( v2785(VarCurr,bitIndex1)
    <=> v2766(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_142,axiom,
    ! [VarCurr] :
      ( v2782(VarCurr)
    <=> ( ( v2783(VarCurr,bitIndex1)
        <=> $false )
        & ( v2783(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_673,axiom,
    ! [VarCurr] :
      ( v2783(VarCurr,bitIndex0)
    <=> v2768(VarCurr) ) ).

fof(addAssignment_672,axiom,
    ! [VarCurr] :
      ( v2783(VarCurr,bitIndex1)
    <=> v2766(VarCurr) ) ).

fof(writeUnaryOperator_246,axiom,
    ! [VarCurr] :
      ( ~ v2780(VarCurr)
    <=> v2764(VarCurr) ) ).

fof(addAssignment_671,axiom,
    ! [VarCurr] :
      ( v2774(VarCurr,bitIndex2)
    <=> v2775(VarCurr,bitIndex2) ) ).

fof(addAssignment_670,axiom,
    ! [VarCurr] :
      ( v2775(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_669,axiom,
    ! [VarCurr] :
      ( ( v2775(VarCurr,bitIndex3)
      <=> v2770(VarCurr,bitIndex2) )
      & ( v2775(VarCurr,bitIndex2)
      <=> v2770(VarCurr,bitIndex1) )
      & ( v2775(VarCurr,bitIndex1)
      <=> v2770(VarCurr,bitIndex0) ) ) ).

fof(addAssignmentInitValue_12,axiom,
    ~ v2770(constB0,bitIndex1) ).

fof(bitBlastConstant_239,axiom,
    ~ bxx0x(bitIndex1) ).

fof(addAssignment_668,axiom,
    ! [VarCurr] :
      ( v2768(VarCurr)
    <=> v137(VarCurr) ) ).

fof(addAssignment_667,axiom,
    ! [VarCurr] :
      ( v2766(VarCurr)
    <=> v88(VarCurr) ) ).

fof(addAssignment_666,axiom,
    ! [VarCurr] :
      ( v2764(VarCurr)
    <=> v84(VarCurr) ) ).

fof(addAssignment_665,axiom,
    ! [VarCurr] :
      ( v2663(VarCurr)
    <=> v2665(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_39,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2737(VarNext)
       => ( v2665(VarNext)
        <=> v2665(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_52,axiom,
    ! [VarNext] :
      ( v2737(VarNext)
     => ( v2665(VarNext)
      <=> v2755(VarNext) ) ) ).

fof(addAssignment_664,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2755(VarNext)
      <=> v2753(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_72,axiom,
    ! [VarCurr] :
      ( ~ v2752(VarCurr)
     => ( v2753(VarCurr)
      <=> v2756(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_74,axiom,
    ! [VarCurr] :
      ( v2752(VarCurr)
     => ( v2753(VarCurr)
      <=> $true ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_71,axiom,
    ! [VarCurr] :
      ( ~ v2669(VarCurr)
     => ( v2756(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_73,axiom,
    ! [VarCurr] :
      ( v2669(VarCurr)
     => ( v2756(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_582,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2737(VarNext)
      <=> ( v2738(VarNext)
          & v2745(VarNext) ) ) ) ).

fof(addAssignment_663,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2745(VarNext)
      <=> v2743(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_581,axiom,
    ! [VarCurr] :
      ( v2743(VarCurr)
    <=> ( v2746(VarCurr)
        | v2752(VarCurr) ) ) ).

fof(writeUnaryOperator_245,axiom,
    ! [VarCurr] :
      ( ~ v2752(VarCurr)
    <=> v2667(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_580,axiom,
    ! [VarCurr] :
      ( v2746(VarCurr)
    <=> ( v2747(VarCurr)
        | v2669(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_579,axiom,
    ! [VarCurr] :
      ( v2747(VarCurr)
    <=> ( v2748(VarCurr)
        & v2751(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_141,axiom,
    ! [VarCurr] :
      ( v2751(VarCurr)
    <=> ( v2731(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_578,axiom,
    ! [VarCurr] :
      ( v2748(VarCurr)
    <=> ( v2749(VarCurr)
        & v2750(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_140,axiom,
    ! [VarCurr] :
      ( v2750(VarCurr)
    <=> ( v2673(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_139,axiom,
    ! [VarCurr] :
      ( v2749(VarCurr)
    <=> ( v2671(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_577,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2738(VarNext)
      <=> ( v2739(VarNext)
          & v2697(VarNext) ) ) ) ).

fof(writeUnaryOperator_244,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2739(VarNext)
      <=> v2704(VarNext) ) ) ).

fof(addAssignmentInitValueVector_6,axiom,
    ( v2665(constB0)
  <=> $true ) ).

fof(addAssignment_662,axiom,
    ! [VarCurr] :
      ( v2731(VarCurr,bitIndex0)
    <=> v2732(VarCurr,bitIndex0) ) ).

fof(addAssignment_661,axiom,
    ! [VarCurr] :
      ( v2732(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_660,axiom,
    ! [VarCurr,B] :
      ( range_6_1(B)
     => ( v2732(VarCurr,B)
      <=> v2733(VarCurr,B) ) ) ).

fof(addAssignment_659,axiom,
    ! [VarNext] :
      ( v2673(VarNext,bitIndex1)
    <=> v2723(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_38,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2724(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2723(VarNext,B)
            <=> v2673(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_51,axiom,
    ! [VarNext] :
      ( v2724(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2723(VarNext,B)
          <=> v2710(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_576,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2724(VarNext)
      <=> v2725(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_575,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2725(VarNext)
      <=> ( v2727(VarNext)
          & v2697(VarNext) ) ) ) ).

fof(writeUnaryOperator_243,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2727(VarNext)
      <=> v2704(VarNext) ) ) ).

fof(addAssignment_658,axiom,
    ! [VarCurr] :
      ( v2675(VarCurr,bitIndex1)
    <=> v2682(VarCurr,bitIndex1) ) ).

fof(addAssignment_657,axiom,
    ! [VarCurr] :
      ( v2677(VarCurr,bitIndex1)
    <=> v2678(VarCurr,bitIndex1) ) ).

fof(addAssignment_656,axiom,
    ! [VarNext] :
      ( v2673(VarNext,bitIndex0)
    <=> v2715(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_37,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2716(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2715(VarNext,B)
            <=> v2673(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_50,axiom,
    ! [VarNext] :
      ( v2716(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2715(VarNext,B)
          <=> v2710(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_574,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2716(VarNext)
      <=> v2717(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_573,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2717(VarNext)
      <=> ( v2719(VarNext)
          & v2697(VarNext) ) ) ) ).

fof(writeUnaryOperator_242,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2719(VarNext)
      <=> v2704(VarNext) ) ) ).

fof(addAssignment_655,axiom,
    ! [VarCurr] :
      ( v2675(VarCurr,bitIndex0)
    <=> v2682(VarCurr,bitIndex0) ) ).

fof(addAssignment_654,axiom,
    ! [VarNext] :
      ( v2673(VarNext,bitIndex2)
    <=> v2699(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_36,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2700(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2699(VarNext,B)
            <=> v2673(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_49,axiom,
    ! [VarNext] :
      ( v2700(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2699(VarNext,B)
          <=> v2710(VarNext,B) ) ) ) ).

fof(addAssignment_653,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2710(VarNext,B)
          <=> v2708(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_70,axiom,
    ! [VarCurr] :
      ( ~ v2711(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2708(VarCurr,B)
          <=> v2675(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_72,axiom,
    ! [VarCurr] :
      ( v2711(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2708(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_241,axiom,
    ! [VarCurr] :
      ( ~ v2711(VarCurr)
    <=> v2667(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_572,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2700(VarNext)
      <=> v2701(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_571,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2701(VarNext)
      <=> ( v2702(VarNext)
          & v2697(VarNext) ) ) ) ).

fof(writeUnaryOperator_240,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2702(VarNext)
      <=> v2704(VarNext) ) ) ).

fof(addAssignment_652,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2704(VarNext)
      <=> v2697(VarCurr) ) ) ).

fof(addAssignment_651,axiom,
    ! [VarCurr] :
      ( v2697(VarCurr)
    <=> v168(VarCurr) ) ).

fof(addAssignment_650,axiom,
    ! [VarCurr] :
      ( v2675(VarCurr,bitIndex2)
    <=> v2682(VarCurr,bitIndex2) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_69,axiom,
    ! [VarCurr] :
      ( ~ v2683(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2682(VarCurr,B)
          <=> v2684(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_71,axiom,
    ! [VarCurr] :
      ( v2683(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2682(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_9,axiom,
    ! [VarCurr] :
      ( ( ~ v2685(VarCurr)
        & ~ v2687(VarCurr)
        & ~ v2691(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v2684(VarCurr,B)
          <=> v2673(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_12,axiom,
    ! [VarCurr] :
      ( v2691(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2684(VarCurr,B)
          <=> v2693(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_24,axiom,
    ! [VarCurr] :
      ( v2687(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2684(VarCurr,B)
          <=> v2689(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_24,axiom,
    ! [VarCurr] :
      ( v2685(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2684(VarCurr,B)
          <=> v2673(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_138,axiom,
    ! [VarCurr] :
      ( v2694(VarCurr)
    <=> ( ( v2695(VarCurr,bitIndex1)
        <=> $true )
        & ( v2695(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_649,axiom,
    ! [VarCurr] :
      ( v2695(VarCurr,bitIndex0)
    <=> v2671(VarCurr) ) ).

fof(addAssignment_648,axiom,
    ! [VarCurr] :
      ( v2695(VarCurr,bitIndex1)
    <=> v2669(VarCurr) ) ).

fof(addAssignment_647,axiom,
    ! [VarCurr] :
      ( v2693(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_646,axiom,
    ! [VarCurr,B] :
      ( range_3_1(B)
     => ( v2693(VarCurr,B)
      <=> v2677(VarCurr,B) ) ) ).

fof(addBitVectorEqualityBitBlasted_137,axiom,
    ! [VarCurr] :
      ( v2691(VarCurr)
    <=> ( ( v2692(VarCurr,bitIndex1)
        <=> $true )
        & ( v2692(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_645,axiom,
    ! [VarCurr] :
      ( v2692(VarCurr,bitIndex0)
    <=> v2671(VarCurr) ) ).

fof(addAssignment_644,axiom,
    ! [VarCurr] :
      ( v2692(VarCurr,bitIndex1)
    <=> v2669(VarCurr) ) ).

fof(addAssignment_643,axiom,
    ! [VarCurr] :
      ( ( v2689(VarCurr,bitIndex2)
      <=> v2673(VarCurr,bitIndex3) )
      & ( v2689(VarCurr,bitIndex1)
      <=> v2673(VarCurr,bitIndex2) )
      & ( v2689(VarCurr,bitIndex0)
      <=> v2673(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_642,axiom,
    ! [VarCurr] :
      ( v2689(VarCurr,bitIndex3)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_136,axiom,
    ! [VarCurr] :
      ( v2687(VarCurr)
    <=> ( ( v2688(VarCurr,bitIndex1)
        <=> $false )
        & ( v2688(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_641,axiom,
    ! [VarCurr] :
      ( v2688(VarCurr,bitIndex0)
    <=> v2671(VarCurr) ) ).

fof(addAssignment_640,axiom,
    ! [VarCurr] :
      ( v2688(VarCurr,bitIndex1)
    <=> v2669(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_135,axiom,
    ! [VarCurr] :
      ( v2685(VarCurr)
    <=> ( ( v2686(VarCurr,bitIndex1)
        <=> $false )
        & ( v2686(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_639,axiom,
    ! [VarCurr] :
      ( v2686(VarCurr,bitIndex0)
    <=> v2671(VarCurr) ) ).

fof(addAssignment_638,axiom,
    ! [VarCurr] :
      ( v2686(VarCurr,bitIndex1)
    <=> v2669(VarCurr) ) ).

fof(writeUnaryOperator_239,axiom,
    ! [VarCurr] :
      ( ~ v2683(VarCurr)
    <=> v2667(VarCurr) ) ).

fof(addAssignment_637,axiom,
    ! [VarCurr] :
      ( v2677(VarCurr,bitIndex2)
    <=> v2678(VarCurr,bitIndex2) ) ).

fof(addAssignment_636,axiom,
    ! [VarCurr] :
      ( v2678(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_635,axiom,
    ! [VarCurr] :
      ( ( v2678(VarCurr,bitIndex3)
      <=> v2673(VarCurr,bitIndex2) )
      & ( v2678(VarCurr,bitIndex2)
      <=> v2673(VarCurr,bitIndex1) )
      & ( v2678(VarCurr,bitIndex1)
      <=> v2673(VarCurr,bitIndex0) ) ) ).

fof(addAssignmentInitValue_11,axiom,
    ~ v2673(constB0,bitIndex1) ).

fof(bitBlastConstant_238,axiom,
    ~ bxx0x(bitIndex1) ).

fof(addAssignment_634,axiom,
    ! [VarCurr] :
      ( v2671(VarCurr)
    <=> v137(VarCurr) ) ).

fof(addAssignment_633,axiom,
    ! [VarCurr] :
      ( v2669(VarCurr)
    <=> v88(VarCurr) ) ).

fof(addAssignment_632,axiom,
    ! [VarCurr] :
      ( v2667(VarCurr)
    <=> v84(VarCurr) ) ).

fof(addAssignment_631,axiom,
    ! [VarCurr] :
      ( v2566(VarCurr)
    <=> v2568(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_35,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2640(VarNext)
       => ( v2568(VarNext)
        <=> v2568(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_48,axiom,
    ! [VarNext] :
      ( v2640(VarNext)
     => ( v2568(VarNext)
      <=> v2658(VarNext) ) ) ).

fof(addAssignment_630,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2658(VarNext)
      <=> v2656(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_68,axiom,
    ! [VarCurr] :
      ( ~ v2655(VarCurr)
     => ( v2656(VarCurr)
      <=> v2659(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_70,axiom,
    ! [VarCurr] :
      ( v2655(VarCurr)
     => ( v2656(VarCurr)
      <=> $true ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_67,axiom,
    ! [VarCurr] :
      ( ~ v2572(VarCurr)
     => ( v2659(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_69,axiom,
    ! [VarCurr] :
      ( v2572(VarCurr)
     => ( v2659(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_570,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2640(VarNext)
      <=> ( v2641(VarNext)
          & v2648(VarNext) ) ) ) ).

fof(addAssignment_629,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2648(VarNext)
      <=> v2646(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_569,axiom,
    ! [VarCurr] :
      ( v2646(VarCurr)
    <=> ( v2649(VarCurr)
        | v2655(VarCurr) ) ) ).

fof(writeUnaryOperator_238,axiom,
    ! [VarCurr] :
      ( ~ v2655(VarCurr)
    <=> v2570(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_568,axiom,
    ! [VarCurr] :
      ( v2649(VarCurr)
    <=> ( v2650(VarCurr)
        | v2572(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_567,axiom,
    ! [VarCurr] :
      ( v2650(VarCurr)
    <=> ( v2651(VarCurr)
        & v2654(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_134,axiom,
    ! [VarCurr] :
      ( v2654(VarCurr)
    <=> ( v2634(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_566,axiom,
    ! [VarCurr] :
      ( v2651(VarCurr)
    <=> ( v2652(VarCurr)
        & v2653(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_133,axiom,
    ! [VarCurr] :
      ( v2653(VarCurr)
    <=> ( v2576(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_132,axiom,
    ! [VarCurr] :
      ( v2652(VarCurr)
    <=> ( v2574(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_565,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2641(VarNext)
      <=> ( v2642(VarNext)
          & v2600(VarNext) ) ) ) ).

fof(writeUnaryOperator_237,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2642(VarNext)
      <=> v2607(VarNext) ) ) ).

fof(addAssignmentInitValueVector_5,axiom,
    ( v2568(constB0)
  <=> $true ) ).

fof(addAssignment_628,axiom,
    ! [VarCurr] :
      ( v2634(VarCurr,bitIndex0)
    <=> v2635(VarCurr,bitIndex0) ) ).

fof(addAssignment_627,axiom,
    ! [VarCurr] :
      ( v2635(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_626,axiom,
    ! [VarCurr,B] :
      ( range_6_1(B)
     => ( v2635(VarCurr,B)
      <=> v2636(VarCurr,B) ) ) ).

fof(addAssignment_625,axiom,
    ! [VarNext] :
      ( v2576(VarNext,bitIndex1)
    <=> v2626(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_34,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2627(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2626(VarNext,B)
            <=> v2576(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_47,axiom,
    ! [VarNext] :
      ( v2627(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2626(VarNext,B)
          <=> v2613(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_564,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2627(VarNext)
      <=> v2628(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_563,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2628(VarNext)
      <=> ( v2630(VarNext)
          & v2600(VarNext) ) ) ) ).

fof(writeUnaryOperator_236,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2630(VarNext)
      <=> v2607(VarNext) ) ) ).

fof(addAssignment_624,axiom,
    ! [VarCurr] :
      ( v2578(VarCurr,bitIndex1)
    <=> v2585(VarCurr,bitIndex1) ) ).

fof(addAssignment_623,axiom,
    ! [VarCurr] :
      ( v2580(VarCurr,bitIndex1)
    <=> v2581(VarCurr,bitIndex1) ) ).

fof(addAssignment_622,axiom,
    ! [VarNext] :
      ( v2576(VarNext,bitIndex0)
    <=> v2618(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_33,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2619(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2618(VarNext,B)
            <=> v2576(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_46,axiom,
    ! [VarNext] :
      ( v2619(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2618(VarNext,B)
          <=> v2613(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_562,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2619(VarNext)
      <=> v2620(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_561,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2620(VarNext)
      <=> ( v2622(VarNext)
          & v2600(VarNext) ) ) ) ).

fof(writeUnaryOperator_235,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2622(VarNext)
      <=> v2607(VarNext) ) ) ).

fof(addAssignment_621,axiom,
    ! [VarCurr] :
      ( v2578(VarCurr,bitIndex0)
    <=> v2585(VarCurr,bitIndex0) ) ).

fof(addAssignment_620,axiom,
    ! [VarNext] :
      ( v2576(VarNext,bitIndex2)
    <=> v2602(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_32,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2603(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2602(VarNext,B)
            <=> v2576(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_45,axiom,
    ! [VarNext] :
      ( v2603(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2602(VarNext,B)
          <=> v2613(VarNext,B) ) ) ) ).

fof(addAssignment_619,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2613(VarNext,B)
          <=> v2611(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_66,axiom,
    ! [VarCurr] :
      ( ~ v2614(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2611(VarCurr,B)
          <=> v2578(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_68,axiom,
    ! [VarCurr] :
      ( v2614(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2611(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_234,axiom,
    ! [VarCurr] :
      ( ~ v2614(VarCurr)
    <=> v2570(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_560,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2603(VarNext)
      <=> v2604(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_559,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2604(VarNext)
      <=> ( v2605(VarNext)
          & v2600(VarNext) ) ) ) ).

fof(writeUnaryOperator_233,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2605(VarNext)
      <=> v2607(VarNext) ) ) ).

fof(addAssignment_618,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2607(VarNext)
      <=> v2600(VarCurr) ) ) ).

fof(addAssignment_617,axiom,
    ! [VarCurr] :
      ( v2600(VarCurr)
    <=> v168(VarCurr) ) ).

fof(addAssignment_616,axiom,
    ! [VarCurr] :
      ( v2578(VarCurr,bitIndex2)
    <=> v2585(VarCurr,bitIndex2) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_65,axiom,
    ! [VarCurr] :
      ( ~ v2586(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2585(VarCurr,B)
          <=> v2587(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_67,axiom,
    ! [VarCurr] :
      ( v2586(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2585(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_8,axiom,
    ! [VarCurr] :
      ( ( ~ v2588(VarCurr)
        & ~ v2590(VarCurr)
        & ~ v2594(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v2587(VarCurr,B)
          <=> v2576(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_11,axiom,
    ! [VarCurr] :
      ( v2594(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2587(VarCurr,B)
          <=> v2596(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_23,axiom,
    ! [VarCurr] :
      ( v2590(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2587(VarCurr,B)
          <=> v2592(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_23,axiom,
    ! [VarCurr] :
      ( v2588(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2587(VarCurr,B)
          <=> v2576(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_131,axiom,
    ! [VarCurr] :
      ( v2597(VarCurr)
    <=> ( ( v2598(VarCurr,bitIndex1)
        <=> $true )
        & ( v2598(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_615,axiom,
    ! [VarCurr] :
      ( v2598(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_614,axiom,
    ! [VarCurr] :
      ( v2598(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(addAssignment_613,axiom,
    ! [VarCurr] :
      ( v2596(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_612,axiom,
    ! [VarCurr,B] :
      ( range_3_1(B)
     => ( v2596(VarCurr,B)
      <=> v2580(VarCurr,B) ) ) ).

fof(addBitVectorEqualityBitBlasted_130,axiom,
    ! [VarCurr] :
      ( v2594(VarCurr)
    <=> ( ( v2595(VarCurr,bitIndex1)
        <=> $true )
        & ( v2595(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_611,axiom,
    ! [VarCurr] :
      ( v2595(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_610,axiom,
    ! [VarCurr] :
      ( v2595(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(addAssignment_609,axiom,
    ! [VarCurr] :
      ( ( v2592(VarCurr,bitIndex2)
      <=> v2576(VarCurr,bitIndex3) )
      & ( v2592(VarCurr,bitIndex1)
      <=> v2576(VarCurr,bitIndex2) )
      & ( v2592(VarCurr,bitIndex0)
      <=> v2576(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_608,axiom,
    ! [VarCurr] :
      ( v2592(VarCurr,bitIndex3)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_129,axiom,
    ! [VarCurr] :
      ( v2590(VarCurr)
    <=> ( ( v2591(VarCurr,bitIndex1)
        <=> $false )
        & ( v2591(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_607,axiom,
    ! [VarCurr] :
      ( v2591(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_606,axiom,
    ! [VarCurr] :
      ( v2591(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_128,axiom,
    ! [VarCurr] :
      ( v2588(VarCurr)
    <=> ( ( v2589(VarCurr,bitIndex1)
        <=> $false )
        & ( v2589(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_605,axiom,
    ! [VarCurr] :
      ( v2589(VarCurr,bitIndex0)
    <=> v2574(VarCurr) ) ).

fof(addAssignment_604,axiom,
    ! [VarCurr] :
      ( v2589(VarCurr,bitIndex1)
    <=> v2572(VarCurr) ) ).

fof(writeUnaryOperator_232,axiom,
    ! [VarCurr] :
      ( ~ v2586(VarCurr)
    <=> v2570(VarCurr) ) ).

fof(addAssignment_603,axiom,
    ! [VarCurr] :
      ( v2580(VarCurr,bitIndex2)
    <=> v2581(VarCurr,bitIndex2) ) ).

fof(addAssignment_602,axiom,
    ! [VarCurr] :
      ( v2581(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_601,axiom,
    ! [VarCurr] :
      ( ( v2581(VarCurr,bitIndex3)
      <=> v2576(VarCurr,bitIndex2) )
      & ( v2581(VarCurr,bitIndex2)
      <=> v2576(VarCurr,bitIndex1) )
      & ( v2581(VarCurr,bitIndex1)
      <=> v2576(VarCurr,bitIndex0) ) ) ).

fof(addAssignmentInitValue_10,axiom,
    ~ v2576(constB0,bitIndex1) ).

fof(bitBlastConstant_237,axiom,
    ~ bxx0x(bitIndex1) ).

fof(addAssignment_600,axiom,
    ! [VarCurr] :
      ( v2574(VarCurr)
    <=> v137(VarCurr) ) ).

fof(addAssignment_599,axiom,
    ! [VarCurr] :
      ( v2572(VarCurr)
    <=> v88(VarCurr) ) ).

fof(addAssignment_598,axiom,
    ! [VarCurr] :
      ( v2570(VarCurr)
    <=> v84(VarCurr) ) ).

fof(addAssignment_597,axiom,
    ! [VarCurr] :
      ( v2469(VarCurr)
    <=> v2471(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_31,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2543(VarNext)
       => ( v2471(VarNext)
        <=> v2471(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_44,axiom,
    ! [VarNext] :
      ( v2543(VarNext)
     => ( v2471(VarNext)
      <=> v2561(VarNext) ) ) ).

fof(addAssignment_596,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2561(VarNext)
      <=> v2559(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_64,axiom,
    ! [VarCurr] :
      ( ~ v2558(VarCurr)
     => ( v2559(VarCurr)
      <=> v2562(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_66,axiom,
    ! [VarCurr] :
      ( v2558(VarCurr)
     => ( v2559(VarCurr)
      <=> $true ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_63,axiom,
    ! [VarCurr] :
      ( ~ v2475(VarCurr)
     => ( v2562(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_65,axiom,
    ! [VarCurr] :
      ( v2475(VarCurr)
     => ( v2562(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_558,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2543(VarNext)
      <=> ( v2544(VarNext)
          & v2551(VarNext) ) ) ) ).

fof(addAssignment_595,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2551(VarNext)
      <=> v2549(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_557,axiom,
    ! [VarCurr] :
      ( v2549(VarCurr)
    <=> ( v2552(VarCurr)
        | v2558(VarCurr) ) ) ).

fof(writeUnaryOperator_231,axiom,
    ! [VarCurr] :
      ( ~ v2558(VarCurr)
    <=> v2473(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_556,axiom,
    ! [VarCurr] :
      ( v2552(VarCurr)
    <=> ( v2553(VarCurr)
        | v2475(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_555,axiom,
    ! [VarCurr] :
      ( v2553(VarCurr)
    <=> ( v2554(VarCurr)
        & v2557(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_127,axiom,
    ! [VarCurr] :
      ( v2557(VarCurr)
    <=> ( v2537(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_554,axiom,
    ! [VarCurr] :
      ( v2554(VarCurr)
    <=> ( v2555(VarCurr)
        & v2556(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_126,axiom,
    ! [VarCurr] :
      ( v2556(VarCurr)
    <=> ( v2479(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_125,axiom,
    ! [VarCurr] :
      ( v2555(VarCurr)
    <=> ( v2477(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_553,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2544(VarNext)
      <=> ( v2545(VarNext)
          & v2503(VarNext) ) ) ) ).

fof(writeUnaryOperator_230,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2545(VarNext)
      <=> v2510(VarNext) ) ) ).

fof(addAssignmentInitValueVector_4,axiom,
    ( v2471(constB0)
  <=> $true ) ).

fof(addAssignment_594,axiom,
    ! [VarCurr] :
      ( v2537(VarCurr,bitIndex0)
    <=> v2538(VarCurr,bitIndex0) ) ).

fof(addAssignment_593,axiom,
    ! [VarCurr] :
      ( v2538(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_592,axiom,
    ! [VarCurr,B] :
      ( range_6_1(B)
     => ( v2538(VarCurr,B)
      <=> v2539(VarCurr,B) ) ) ).

fof(addAssignment_591,axiom,
    ! [VarNext] :
      ( v2479(VarNext,bitIndex1)
    <=> v2529(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_30,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2530(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2529(VarNext,B)
            <=> v2479(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_43,axiom,
    ! [VarNext] :
      ( v2530(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2529(VarNext,B)
          <=> v2516(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_552,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2530(VarNext)
      <=> v2531(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_551,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2531(VarNext)
      <=> ( v2533(VarNext)
          & v2503(VarNext) ) ) ) ).

fof(writeUnaryOperator_229,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2533(VarNext)
      <=> v2510(VarNext) ) ) ).

fof(addAssignment_590,axiom,
    ! [VarCurr] :
      ( v2481(VarCurr,bitIndex1)
    <=> v2488(VarCurr,bitIndex1) ) ).

fof(addAssignment_589,axiom,
    ! [VarCurr] :
      ( v2483(VarCurr,bitIndex1)
    <=> v2484(VarCurr,bitIndex1) ) ).

fof(addAssignment_588,axiom,
    ! [VarNext] :
      ( v2479(VarNext,bitIndex0)
    <=> v2521(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_29,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2522(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2521(VarNext,B)
            <=> v2479(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_42,axiom,
    ! [VarNext] :
      ( v2522(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2521(VarNext,B)
          <=> v2516(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_550,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2522(VarNext)
      <=> v2523(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_549,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2523(VarNext)
      <=> ( v2525(VarNext)
          & v2503(VarNext) ) ) ) ).

fof(writeUnaryOperator_228,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2525(VarNext)
      <=> v2510(VarNext) ) ) ).

fof(addAssignment_587,axiom,
    ! [VarCurr] :
      ( v2481(VarCurr,bitIndex0)
    <=> v2488(VarCurr,bitIndex0) ) ).

fof(addAssignment_586,axiom,
    ! [VarNext] :
      ( v2479(VarNext,bitIndex2)
    <=> v2505(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_28,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2506(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2505(VarNext,B)
            <=> v2479(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_41,axiom,
    ! [VarNext] :
      ( v2506(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2505(VarNext,B)
          <=> v2516(VarNext,B) ) ) ) ).

fof(addAssignment_585,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2516(VarNext,B)
          <=> v2514(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_62,axiom,
    ! [VarCurr] :
      ( ~ v2517(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2514(VarCurr,B)
          <=> v2481(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_64,axiom,
    ! [VarCurr] :
      ( v2517(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2514(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_227,axiom,
    ! [VarCurr] :
      ( ~ v2517(VarCurr)
    <=> v2473(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_548,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2506(VarNext)
      <=> v2507(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_547,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2507(VarNext)
      <=> ( v2508(VarNext)
          & v2503(VarNext) ) ) ) ).

fof(writeUnaryOperator_226,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2508(VarNext)
      <=> v2510(VarNext) ) ) ).

fof(addAssignment_584,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2510(VarNext)
      <=> v2503(VarCurr) ) ) ).

fof(addAssignment_583,axiom,
    ! [VarCurr] :
      ( v2503(VarCurr)
    <=> v168(VarCurr) ) ).

fof(addAssignment_582,axiom,
    ! [VarCurr] :
      ( v2481(VarCurr,bitIndex2)
    <=> v2488(VarCurr,bitIndex2) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_61,axiom,
    ! [VarCurr] :
      ( ~ v2489(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2488(VarCurr,B)
          <=> v2490(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_63,axiom,
    ! [VarCurr] :
      ( v2489(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2488(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_7,axiom,
    ! [VarCurr] :
      ( ( ~ v2491(VarCurr)
        & ~ v2493(VarCurr)
        & ~ v2497(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v2490(VarCurr,B)
          <=> v2479(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_10,axiom,
    ! [VarCurr] :
      ( v2497(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2490(VarCurr,B)
          <=> v2499(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_22,axiom,
    ! [VarCurr] :
      ( v2493(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2490(VarCurr,B)
          <=> v2495(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_22,axiom,
    ! [VarCurr] :
      ( v2491(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2490(VarCurr,B)
          <=> v2479(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_124,axiom,
    ! [VarCurr] :
      ( v2500(VarCurr)
    <=> ( ( v2501(VarCurr,bitIndex1)
        <=> $true )
        & ( v2501(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_581,axiom,
    ! [VarCurr] :
      ( v2501(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_580,axiom,
    ! [VarCurr] :
      ( v2501(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(addAssignment_579,axiom,
    ! [VarCurr] :
      ( v2499(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_578,axiom,
    ! [VarCurr,B] :
      ( range_3_1(B)
     => ( v2499(VarCurr,B)
      <=> v2483(VarCurr,B) ) ) ).

fof(addBitVectorEqualityBitBlasted_123,axiom,
    ! [VarCurr] :
      ( v2497(VarCurr)
    <=> ( ( v2498(VarCurr,bitIndex1)
        <=> $true )
        & ( v2498(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_577,axiom,
    ! [VarCurr] :
      ( v2498(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_576,axiom,
    ! [VarCurr] :
      ( v2498(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(addAssignment_575,axiom,
    ! [VarCurr] :
      ( ( v2495(VarCurr,bitIndex2)
      <=> v2479(VarCurr,bitIndex3) )
      & ( v2495(VarCurr,bitIndex1)
      <=> v2479(VarCurr,bitIndex2) )
      & ( v2495(VarCurr,bitIndex0)
      <=> v2479(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_574,axiom,
    ! [VarCurr] :
      ( v2495(VarCurr,bitIndex3)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_122,axiom,
    ! [VarCurr] :
      ( v2493(VarCurr)
    <=> ( ( v2494(VarCurr,bitIndex1)
        <=> $false )
        & ( v2494(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_573,axiom,
    ! [VarCurr] :
      ( v2494(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_572,axiom,
    ! [VarCurr] :
      ( v2494(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_121,axiom,
    ! [VarCurr] :
      ( v2491(VarCurr)
    <=> ( ( v2492(VarCurr,bitIndex1)
        <=> $false )
        & ( v2492(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_571,axiom,
    ! [VarCurr] :
      ( v2492(VarCurr,bitIndex0)
    <=> v2477(VarCurr) ) ).

fof(addAssignment_570,axiom,
    ! [VarCurr] :
      ( v2492(VarCurr,bitIndex1)
    <=> v2475(VarCurr) ) ).

fof(writeUnaryOperator_225,axiom,
    ! [VarCurr] :
      ( ~ v2489(VarCurr)
    <=> v2473(VarCurr) ) ).

fof(addAssignment_569,axiom,
    ! [VarCurr] :
      ( v2483(VarCurr,bitIndex2)
    <=> v2484(VarCurr,bitIndex2) ) ).

fof(addAssignment_568,axiom,
    ! [VarCurr] :
      ( v2484(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_567,axiom,
    ! [VarCurr] :
      ( ( v2484(VarCurr,bitIndex3)
      <=> v2479(VarCurr,bitIndex2) )
      & ( v2484(VarCurr,bitIndex2)
      <=> v2479(VarCurr,bitIndex1) )
      & ( v2484(VarCurr,bitIndex1)
      <=> v2479(VarCurr,bitIndex0) ) ) ).

fof(addAssignmentInitValue_9,axiom,
    ~ v2479(constB0,bitIndex1) ).

fof(bitBlastConstant_236,axiom,
    ~ bxx0x(bitIndex1) ).

fof(addAssignment_566,axiom,
    ! [VarCurr] :
      ( v2477(VarCurr)
    <=> v137(VarCurr) ) ).

fof(addAssignment_565,axiom,
    ! [VarCurr] :
      ( v2475(VarCurr)
    <=> v88(VarCurr) ) ).

fof(addAssignment_564,axiom,
    ! [VarCurr] :
      ( v2473(VarCurr)
    <=> v84(VarCurr) ) ).

fof(addAssignment_563,axiom,
    ! [VarCurr] :
      ( v2370(VarCurr)
    <=> v2372(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_27,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2446(VarNext)
       => ( v2372(VarNext)
        <=> v2372(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_40,axiom,
    ! [VarNext] :
      ( v2446(VarNext)
     => ( v2372(VarNext)
      <=> v2464(VarNext) ) ) ).

fof(addAssignment_562,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2464(VarNext)
      <=> v2462(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_60,axiom,
    ! [VarCurr] :
      ( ~ v2461(VarCurr)
     => ( v2462(VarCurr)
      <=> v2465(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_62,axiom,
    ! [VarCurr] :
      ( v2461(VarCurr)
     => ( v2462(VarCurr)
      <=> $true ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_59,axiom,
    ! [VarCurr] :
      ( ~ v2376(VarCurr)
     => ( v2465(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_61,axiom,
    ! [VarCurr] :
      ( v2376(VarCurr)
     => ( v2465(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_546,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2446(VarNext)
      <=> ( v2447(VarNext)
          & v2454(VarNext) ) ) ) ).

fof(addAssignment_561,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2454(VarNext)
      <=> v2452(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_545,axiom,
    ! [VarCurr] :
      ( v2452(VarCurr)
    <=> ( v2455(VarCurr)
        | v2461(VarCurr) ) ) ).

fof(writeUnaryOperator_224,axiom,
    ! [VarCurr] :
      ( ~ v2461(VarCurr)
    <=> v2374(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_544,axiom,
    ! [VarCurr] :
      ( v2455(VarCurr)
    <=> ( v2456(VarCurr)
        | v2376(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_543,axiom,
    ! [VarCurr] :
      ( v2456(VarCurr)
    <=> ( v2457(VarCurr)
        & v2460(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_120,axiom,
    ! [VarCurr] :
      ( v2460(VarCurr)
    <=> ( v2438(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_542,axiom,
    ! [VarCurr] :
      ( v2457(VarCurr)
    <=> ( v2458(VarCurr)
        & v2459(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_119,axiom,
    ! [VarCurr] :
      ( v2459(VarCurr)
    <=> ( v2380(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_118,axiom,
    ! [VarCurr] :
      ( v2458(VarCurr)
    <=> ( v2378(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_541,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2447(VarNext)
      <=> ( v2448(VarNext)
          & v2404(VarNext) ) ) ) ).

fof(writeUnaryOperator_223,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2448(VarNext)
      <=> v2411(VarNext) ) ) ).

fof(addAssignmentInitValueVector_3,axiom,
    ( v2372(constB0)
  <=> $true ) ).

fof(addAssignment_560,axiom,
    ! [VarCurr] :
      ( v2438(VarCurr,bitIndex0)
    <=> v2439(VarCurr,bitIndex0) ) ).

fof(addAssignment_559,axiom,
    ! [VarCurr] :
      ( v2439(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_558,axiom,
    ! [VarCurr,B] :
      ( range_6_1(B)
     => ( v2439(VarCurr,B)
      <=> v2440(VarCurr,B) ) ) ).

fof(addAssignmentInitValue_8,axiom,
    ~ v2440(constB0,bitIndex2) ).

fof(addAssignmentInitValue_7,axiom,
    ~ v2440(constB0,bitIndex1) ).

fof(addAssignmentInitValue_6,axiom,
    v2440(constB0,bitIndex0) ).

fof(bitBlastConstant_235,axiom,
    ~ bxxxx001(bitIndex2) ).

fof(bitBlastConstant_234,axiom,
    ~ bxxxx001(bitIndex1) ).

fof(bitBlastConstant_233,axiom,
    bxxxx001(bitIndex0) ).

fof(addAssignment_557,axiom,
    ! [VarNext] :
      ( v2380(VarNext,bitIndex1)
    <=> v2430(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_26,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2431(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2430(VarNext,B)
            <=> v2380(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_39,axiom,
    ! [VarNext] :
      ( v2431(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2430(VarNext,B)
          <=> v2417(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_540,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2431(VarNext)
      <=> v2432(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_539,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2432(VarNext)
      <=> ( v2434(VarNext)
          & v2404(VarNext) ) ) ) ).

fof(writeUnaryOperator_222,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2434(VarNext)
      <=> v2411(VarNext) ) ) ).

fof(addAssignment_556,axiom,
    ! [VarCurr] :
      ( v2382(VarCurr,bitIndex1)
    <=> v2389(VarCurr,bitIndex1) ) ).

fof(addAssignment_555,axiom,
    ! [VarCurr] :
      ( v2384(VarCurr,bitIndex1)
    <=> v2385(VarCurr,bitIndex1) ) ).

fof(addAssignment_554,axiom,
    ! [VarNext] :
      ( v2380(VarNext,bitIndex0)
    <=> v2422(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_25,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2423(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2422(VarNext,B)
            <=> v2380(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_38,axiom,
    ! [VarNext] :
      ( v2423(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2422(VarNext,B)
          <=> v2417(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_538,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2423(VarNext)
      <=> v2424(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_537,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2424(VarNext)
      <=> ( v2426(VarNext)
          & v2404(VarNext) ) ) ) ).

fof(writeUnaryOperator_221,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2426(VarNext)
      <=> v2411(VarNext) ) ) ).

fof(addAssignment_553,axiom,
    ! [VarCurr] :
      ( v2382(VarCurr,bitIndex0)
    <=> v2389(VarCurr,bitIndex0) ) ).

fof(addAssignment_552,axiom,
    ! [VarNext] :
      ( v2380(VarNext,bitIndex2)
    <=> v2406(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_24,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2407(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2406(VarNext,B)
            <=> v2380(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_37,axiom,
    ! [VarNext] :
      ( v2407(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2406(VarNext,B)
          <=> v2417(VarNext,B) ) ) ) ).

fof(addAssignment_551,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2417(VarNext,B)
          <=> v2415(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_58,axiom,
    ! [VarCurr] :
      ( ~ v2418(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2415(VarCurr,B)
          <=> v2382(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_60,axiom,
    ! [VarCurr] :
      ( v2418(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2415(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_220,axiom,
    ! [VarCurr] :
      ( ~ v2418(VarCurr)
    <=> v2374(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_536,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2407(VarNext)
      <=> v2408(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_535,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2408(VarNext)
      <=> ( v2409(VarNext)
          & v2404(VarNext) ) ) ) ).

fof(writeUnaryOperator_219,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2409(VarNext)
      <=> v2411(VarNext) ) ) ).

fof(addAssignment_550,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2411(VarNext)
      <=> v2404(VarCurr) ) ) ).

fof(addAssignment_549,axiom,
    ! [VarCurr] :
      ( v2404(VarCurr)
    <=> v168(VarCurr) ) ).

fof(addAssignment_548,axiom,
    ! [VarCurr] :
      ( v2382(VarCurr,bitIndex2)
    <=> v2389(VarCurr,bitIndex2) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_57,axiom,
    ! [VarCurr] :
      ( ~ v2390(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2389(VarCurr,B)
          <=> v2391(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_59,axiom,
    ! [VarCurr] :
      ( v2390(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2389(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_6,axiom,
    ! [VarCurr] :
      ( ( ~ v2392(VarCurr)
        & ~ v2394(VarCurr)
        & ~ v2398(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v2391(VarCurr,B)
          <=> v2380(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_9,axiom,
    ! [VarCurr] :
      ( v2398(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2391(VarCurr,B)
          <=> v2400(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_21,axiom,
    ! [VarCurr] :
      ( v2394(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2391(VarCurr,B)
          <=> v2396(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_21,axiom,
    ! [VarCurr] :
      ( v2392(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2391(VarCurr,B)
          <=> v2380(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_117,axiom,
    ! [VarCurr] :
      ( v2401(VarCurr)
    <=> ( ( v2402(VarCurr,bitIndex1)
        <=> $true )
        & ( v2402(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_547,axiom,
    ! [VarCurr] :
      ( v2402(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_546,axiom,
    ! [VarCurr] :
      ( v2402(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(addAssignment_545,axiom,
    ! [VarCurr] :
      ( v2400(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_544,axiom,
    ! [VarCurr,B] :
      ( range_3_1(B)
     => ( v2400(VarCurr,B)
      <=> v2384(VarCurr,B) ) ) ).

fof(addBitVectorEqualityBitBlasted_116,axiom,
    ! [VarCurr] :
      ( v2398(VarCurr)
    <=> ( ( v2399(VarCurr,bitIndex1)
        <=> $true )
        & ( v2399(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_543,axiom,
    ! [VarCurr] :
      ( v2399(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_542,axiom,
    ! [VarCurr] :
      ( v2399(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(addAssignment_541,axiom,
    ! [VarCurr] :
      ( ( v2396(VarCurr,bitIndex2)
      <=> v2380(VarCurr,bitIndex3) )
      & ( v2396(VarCurr,bitIndex1)
      <=> v2380(VarCurr,bitIndex2) )
      & ( v2396(VarCurr,bitIndex0)
      <=> v2380(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_540,axiom,
    ! [VarCurr] :
      ( v2396(VarCurr,bitIndex3)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_115,axiom,
    ! [VarCurr] :
      ( v2394(VarCurr)
    <=> ( ( v2395(VarCurr,bitIndex1)
        <=> $false )
        & ( v2395(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_539,axiom,
    ! [VarCurr] :
      ( v2395(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_538,axiom,
    ! [VarCurr] :
      ( v2395(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_114,axiom,
    ! [VarCurr] :
      ( v2392(VarCurr)
    <=> ( ( v2393(VarCurr,bitIndex1)
        <=> $false )
        & ( v2393(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_537,axiom,
    ! [VarCurr] :
      ( v2393(VarCurr,bitIndex0)
    <=> v2378(VarCurr) ) ).

fof(addAssignment_536,axiom,
    ! [VarCurr] :
      ( v2393(VarCurr,bitIndex1)
    <=> v2376(VarCurr) ) ).

fof(writeUnaryOperator_218,axiom,
    ! [VarCurr] :
      ( ~ v2390(VarCurr)
    <=> v2374(VarCurr) ) ).

fof(addAssignment_535,axiom,
    ! [VarCurr] :
      ( v2384(VarCurr,bitIndex2)
    <=> v2385(VarCurr,bitIndex2) ) ).

fof(addAssignment_534,axiom,
    ! [VarCurr] :
      ( v2385(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_533,axiom,
    ! [VarCurr] :
      ( ( v2385(VarCurr,bitIndex3)
      <=> v2380(VarCurr,bitIndex2) )
      & ( v2385(VarCurr,bitIndex2)
      <=> v2380(VarCurr,bitIndex1) )
      & ( v2385(VarCurr,bitIndex1)
      <=> v2380(VarCurr,bitIndex0) ) ) ).

fof(addAssignmentInitValue_5,axiom,
    ~ v2380(constB0,bitIndex1) ).

fof(bitBlastConstant_232,axiom,
    ~ bxx0x(bitIndex1) ).

fof(addAssignment_532,axiom,
    ! [VarCurr] :
      ( v2378(VarCurr)
    <=> v137(VarCurr) ) ).

fof(addAssignment_531,axiom,
    ! [VarCurr] :
      ( v2376(VarCurr)
    <=> v88(VarCurr) ) ).

fof(addAssignment_530,axiom,
    ! [VarCurr] :
      ( v2374(VarCurr)
    <=> v84(VarCurr) ) ).

fof(addAssignment_529,axiom,
    ! [VarCurr] :
      ( v2273(VarCurr)
    <=> v2275(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_23,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2347(VarNext)
       => ( v2275(VarNext)
        <=> v2275(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_36,axiom,
    ! [VarNext] :
      ( v2347(VarNext)
     => ( v2275(VarNext)
      <=> v2365(VarNext) ) ) ).

fof(addAssignment_528,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2365(VarNext)
      <=> v2363(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_56,axiom,
    ! [VarCurr] :
      ( ~ v2362(VarCurr)
     => ( v2363(VarCurr)
      <=> v2366(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_58,axiom,
    ! [VarCurr] :
      ( v2362(VarCurr)
     => ( v2363(VarCurr)
      <=> $true ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_55,axiom,
    ! [VarCurr] :
      ( ~ v2279(VarCurr)
     => ( v2366(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_57,axiom,
    ! [VarCurr] :
      ( v2279(VarCurr)
     => ( v2366(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_534,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2347(VarNext)
      <=> ( v2348(VarNext)
          & v2355(VarNext) ) ) ) ).

fof(addAssignment_527,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2355(VarNext)
      <=> v2353(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_533,axiom,
    ! [VarCurr] :
      ( v2353(VarCurr)
    <=> ( v2356(VarCurr)
        | v2362(VarCurr) ) ) ).

fof(writeUnaryOperator_217,axiom,
    ! [VarCurr] :
      ( ~ v2362(VarCurr)
    <=> v2277(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_532,axiom,
    ! [VarCurr] :
      ( v2356(VarCurr)
    <=> ( v2357(VarCurr)
        | v2279(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_531,axiom,
    ! [VarCurr] :
      ( v2357(VarCurr)
    <=> ( v2358(VarCurr)
        & v2361(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_113,axiom,
    ! [VarCurr] :
      ( v2361(VarCurr)
    <=> ( v2341(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_530,axiom,
    ! [VarCurr] :
      ( v2358(VarCurr)
    <=> ( v2359(VarCurr)
        & v2360(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_112,axiom,
    ! [VarCurr] :
      ( v2360(VarCurr)
    <=> ( v2283(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_111,axiom,
    ! [VarCurr] :
      ( v2359(VarCurr)
    <=> ( v2281(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_529,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2348(VarNext)
      <=> ( v2349(VarNext)
          & v2307(VarNext) ) ) ) ).

fof(writeUnaryOperator_216,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2349(VarNext)
      <=> v2314(VarNext) ) ) ).

fof(addAssignmentInitValueVector_2,axiom,
    ( v2275(constB0)
  <=> $true ) ).

fof(addAssignment_526,axiom,
    ! [VarCurr] :
      ( v2341(VarCurr,bitIndex0)
    <=> v2342(VarCurr,bitIndex0) ) ).

fof(addAssignment_525,axiom,
    ! [VarCurr] :
      ( v2342(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_524,axiom,
    ! [VarCurr,B] :
      ( range_6_1(B)
     => ( v2342(VarCurr,B)
      <=> v2343(VarCurr,B) ) ) ).

fof(addAssignment_523,axiom,
    ! [VarNext] :
      ( v2283(VarNext,bitIndex1)
    <=> v2333(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_22,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2334(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2333(VarNext,B)
            <=> v2283(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_35,axiom,
    ! [VarNext] :
      ( v2334(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2333(VarNext,B)
          <=> v2320(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_528,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2334(VarNext)
      <=> v2335(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_527,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2335(VarNext)
      <=> ( v2337(VarNext)
          & v2307(VarNext) ) ) ) ).

fof(writeUnaryOperator_215,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2337(VarNext)
      <=> v2314(VarNext) ) ) ).

fof(addAssignment_522,axiom,
    ! [VarCurr] :
      ( v2285(VarCurr,bitIndex1)
    <=> v2292(VarCurr,bitIndex1) ) ).

fof(addAssignment_521,axiom,
    ! [VarCurr] :
      ( v2287(VarCurr,bitIndex1)
    <=> v2288(VarCurr,bitIndex1) ) ).

fof(addAssignment_520,axiom,
    ! [VarNext] :
      ( v2283(VarNext,bitIndex0)
    <=> v2325(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1_21,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2326(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2325(VarNext,B)
            <=> v2283(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_34,axiom,
    ! [VarNext] :
      ( v2326(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2325(VarNext,B)
          <=> v2320(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_526,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2326(VarNext)
      <=> v2327(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_525,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2327(VarNext)
      <=> ( v2329(VarNext)
          & v2307(VarNext) ) ) ) ).

fof(writeUnaryOperator_214,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2329(VarNext)
      <=> v2314(VarNext) ) ) ).

fof(addAssignment_519,axiom,
    ! [VarCurr] :
      ( v2285(VarCurr,bitIndex0)
    <=> v2292(VarCurr,bitIndex0) ) ).

fof(addAssignment_518,axiom,
    ! [VarNext] :
      ( v2283(VarNext,bitIndex2)
    <=> v2309(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_20,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2310(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v2309(VarNext,B)
            <=> v2283(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_33,axiom,
    ! [VarNext] :
      ( v2310(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2309(VarNext,B)
          <=> v2320(VarNext,B) ) ) ) ).

fof(addAssignment_517,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v2320(VarNext,B)
          <=> v2318(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_54,axiom,
    ! [VarCurr] :
      ( ~ v2321(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2318(VarCurr,B)
          <=> v2285(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_56,axiom,
    ! [VarCurr] :
      ( v2321(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2318(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_213,axiom,
    ! [VarCurr] :
      ( ~ v2321(VarCurr)
    <=> v2277(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_524,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2310(VarNext)
      <=> v2311(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_523,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2311(VarNext)
      <=> ( v2312(VarNext)
          & v2307(VarNext) ) ) ) ).

fof(writeUnaryOperator_212,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2312(VarNext)
      <=> v2314(VarNext) ) ) ).

fof(addAssignment_516,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2314(VarNext)
      <=> v2307(VarCurr) ) ) ).

fof(addAssignment_515,axiom,
    ! [VarCurr] :
      ( v2307(VarCurr)
    <=> v168(VarCurr) ) ).

fof(addAssignment_514,axiom,
    ! [VarCurr] :
      ( v2285(VarCurr,bitIndex2)
    <=> v2292(VarCurr,bitIndex2) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_53,axiom,
    ! [VarCurr] :
      ( ~ v2293(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2292(VarCurr,B)
          <=> v2294(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_55,axiom,
    ! [VarCurr] :
      ( v2293(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2292(VarCurr,B)
          <=> $false ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_5,axiom,
    ! [VarCurr] :
      ( ( ~ v2295(VarCurr)
        & ~ v2297(VarCurr)
        & ~ v2301(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v2294(VarCurr,B)
          <=> v2283(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_8,axiom,
    ! [VarCurr] :
      ( v2301(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2294(VarCurr,B)
          <=> v2303(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_20,axiom,
    ! [VarCurr] :
      ( v2297(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2294(VarCurr,B)
          <=> v2299(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_20,axiom,
    ! [VarCurr] :
      ( v2295(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v2294(VarCurr,B)
          <=> v2283(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_110,axiom,
    ! [VarCurr] :
      ( v2304(VarCurr)
    <=> ( ( v2305(VarCurr,bitIndex1)
        <=> $true )
        & ( v2305(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_513,axiom,
    ! [VarCurr] :
      ( v2305(VarCurr,bitIndex0)
    <=> v2281(VarCurr) ) ).

fof(addAssignment_512,axiom,
    ! [VarCurr] :
      ( v2305(VarCurr,bitIndex1)
    <=> v2279(VarCurr) ) ).

fof(addAssignment_511,axiom,
    ! [VarCurr] :
      ( v2303(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_510,axiom,
    ! [VarCurr,B] :
      ( range_3_1(B)
     => ( v2303(VarCurr,B)
      <=> v2287(VarCurr,B) ) ) ).

fof(addBitVectorEqualityBitBlasted_109,axiom,
    ! [VarCurr] :
      ( v2301(VarCurr)
    <=> ( ( v2302(VarCurr,bitIndex1)
        <=> $true )
        & ( v2302(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_509,axiom,
    ! [VarCurr] :
      ( v2302(VarCurr,bitIndex0)
    <=> v2281(VarCurr) ) ).

fof(addAssignment_508,axiom,
    ! [VarCurr] :
      ( v2302(VarCurr,bitIndex1)
    <=> v2279(VarCurr) ) ).

fof(addAssignment_507,axiom,
    ! [VarCurr] :
      ( ( v2299(VarCurr,bitIndex2)
      <=> v2283(VarCurr,bitIndex3) )
      & ( v2299(VarCurr,bitIndex1)
      <=> v2283(VarCurr,bitIndex2) )
      & ( v2299(VarCurr,bitIndex0)
      <=> v2283(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_506,axiom,
    ! [VarCurr] :
      ( v2299(VarCurr,bitIndex3)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_108,axiom,
    ! [VarCurr] :
      ( v2297(VarCurr)
    <=> ( ( v2298(VarCurr,bitIndex1)
        <=> $false )
        & ( v2298(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_505,axiom,
    ! [VarCurr] :
      ( v2298(VarCurr,bitIndex0)
    <=> v2281(VarCurr) ) ).

fof(addAssignment_504,axiom,
    ! [VarCurr] :
      ( v2298(VarCurr,bitIndex1)
    <=> v2279(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_107,axiom,
    ! [VarCurr] :
      ( v2295(VarCurr)
    <=> ( ( v2296(VarCurr,bitIndex1)
        <=> $false )
        & ( v2296(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_503,axiom,
    ! [VarCurr] :
      ( v2296(VarCurr,bitIndex0)
    <=> v2281(VarCurr) ) ).

fof(addAssignment_502,axiom,
    ! [VarCurr] :
      ( v2296(VarCurr,bitIndex1)
    <=> v2279(VarCurr) ) ).

fof(writeUnaryOperator_211,axiom,
    ! [VarCurr] :
      ( ~ v2293(VarCurr)
    <=> v2277(VarCurr) ) ).

fof(addAssignment_501,axiom,
    ! [VarCurr] :
      ( v2287(VarCurr,bitIndex2)
    <=> v2288(VarCurr,bitIndex2) ) ).

fof(addAssignment_500,axiom,
    ! [VarCurr] :
      ( v2288(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_499,axiom,
    ! [VarCurr] :
      ( ( v2288(VarCurr,bitIndex3)
      <=> v2283(VarCurr,bitIndex2) )
      & ( v2288(VarCurr,bitIndex2)
      <=> v2283(VarCurr,bitIndex1) )
      & ( v2288(VarCurr,bitIndex1)
      <=> v2283(VarCurr,bitIndex0) ) ) ).

fof(addAssignmentInitValue_4,axiom,
    ~ v2283(constB0,bitIndex1) ).

fof(bitBlastConstant_231,axiom,
    ~ bxx0x(bitIndex1) ).

fof(addAssignment_498,axiom,
    ! [VarCurr] :
      ( v2281(VarCurr)
    <=> v137(VarCurr) ) ).

fof(addAssignment_497,axiom,
    ! [VarCurr] :
      ( v2279(VarCurr)
    <=> v88(VarCurr) ) ).

fof(addAssignment_496,axiom,
    ! [VarCurr] :
      ( v2277(VarCurr)
    <=> v84(VarCurr) ) ).

fof(addAssignment_495,axiom,
    ! [VarCurr] :
      ( v78(VarCurr)
    <=> v80(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_19,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2250(VarNext)
       => ( v80(VarNext)
        <=> v80(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_32,axiom,
    ! [VarNext] :
      ( v2250(VarNext)
     => ( v80(VarNext)
      <=> v2268(VarNext) ) ) ).

fof(addAssignment_494,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2268(VarNext)
      <=> v2266(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_52,axiom,
    ! [VarCurr] :
      ( ~ v2265(VarCurr)
     => ( v2266(VarCurr)
      <=> v2269(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_54,axiom,
    ! [VarCurr] :
      ( v2265(VarCurr)
     => ( v2266(VarCurr)
      <=> $true ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_51,axiom,
    ! [VarCurr] :
      ( ~ v86(VarCurr)
     => ( v2269(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_53,axiom,
    ! [VarCurr] :
      ( v86(VarCurr)
     => ( v2269(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_522,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2250(VarNext)
      <=> ( v2251(VarNext)
          & v2258(VarNext) ) ) ) ).

fof(addAssignment_493,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2258(VarNext)
      <=> v2256(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_521,axiom,
    ! [VarCurr] :
      ( v2256(VarCurr)
    <=> ( v2259(VarCurr)
        | v2265(VarCurr) ) ) ).

fof(writeUnaryOperator_210,axiom,
    ! [VarCurr] :
      ( ~ v2265(VarCurr)
    <=> v82(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_520,axiom,
    ! [VarCurr] :
      ( v2259(VarCurr)
    <=> ( v2260(VarCurr)
        | v86(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_519,axiom,
    ! [VarCurr] :
      ( v2260(VarCurr)
    <=> ( v2261(VarCurr)
        & v2264(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_106,axiom,
    ! [VarCurr] :
      ( v2264(VarCurr)
    <=> ( v2242(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_518,axiom,
    ! [VarCurr] :
      ( v2261(VarCurr)
    <=> ( v2262(VarCurr)
        & v2263(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_105,axiom,
    ! [VarCurr] :
      ( v2263(VarCurr)
    <=> ( v130(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_104,axiom,
    ! [VarCurr] :
      ( v2262(VarCurr)
    <=> ( v135(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_517,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2251(VarNext)
      <=> ( v2252(VarNext)
          & v166(VarNext) ) ) ) ).

fof(writeUnaryOperator_209,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2252(VarNext)
      <=> v179(VarNext) ) ) ).

fof(addAssignmentInitValueVector_1,axiom,
    ( v80(constB0)
  <=> $true ) ).

fof(addAssignment_492,axiom,
    ! [VarCurr] :
      ( v2242(VarCurr,bitIndex0)
    <=> v2243(VarCurr,bitIndex0) ) ).

fof(addAssignment_491,axiom,
    ! [VarCurr] :
      ( v2243(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_490,axiom,
    ! [VarCurr,B] :
      ( range_6_1(B)
     => ( v2243(VarCurr,B)
      <=> v2244(VarCurr,B) ) ) ).

fof(range_axiom_13,axiom,
    ! [B] :
      ( range_6_1(B)
    <=> ( $false
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B ) ) ).

fof(addAssignmentInitValue_3,axiom,
    ~ v2244(constB0,bitIndex2) ).

fof(addAssignmentInitValue_2,axiom,
    ~ v2244(constB0,bitIndex1) ).

fof(addAssignmentInitValue_1,axiom,
    v2244(constB0,bitIndex0) ).

fof(bitBlastConstant_230,axiom,
    ~ bxxxx001(bitIndex2) ).

fof(bitBlastConstant_229,axiom,
    ~ bxxxx001(bitIndex1) ).

fof(bitBlastConstant_228,axiom,
    bxxxx001(bitIndex0) ).

fof(addAssignment_489,axiom,
    ! [VarCurr] :
      ( v86(VarCurr)
    <=> v88(VarCurr) ) ).

fof(addAssignment_488,axiom,
    ! [VarCurr] :
      ( v88(VarCurr)
    <=> v90(VarCurr) ) ).

fof(addAssignment_487,axiom,
    ! [VarCurr] :
      ( v90(VarCurr)
    <=> v92(VarCurr) ) ).

fof(addAssignment_486,axiom,
    ! [VarCurr] :
      ( v92(VarCurr)
    <=> v94(VarCurr) ) ).

fof(addAssignment_485,axiom,
    ! [VarCurr] :
      ( v94(VarCurr)
    <=> v96(VarCurr) ) ).

fof(addAssignment_484,axiom,
    ! [VarCurr] :
      ( v96(VarCurr)
    <=> v98(VarCurr) ) ).

fof(addAssignment_483,axiom,
    ! [VarCurr] :
      ( v98(VarCurr)
    <=> v100(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_18,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2221(VarNext)
       => ( v100(VarNext)
        <=> v100(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_31,axiom,
    ! [VarNext] :
      ( v2221(VarNext)
     => ( v100(VarNext)
      <=> v2229(VarNext) ) ) ).

fof(addAssignment_482,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2229(VarNext)
      <=> v2227(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_50,axiom,
    ! [VarCurr] :
      ( ~ v2230(VarCurr)
     => ( v2227(VarCurr)
      <=> v2231(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_52,axiom,
    ! [VarCurr] :
      ( v2230(VarCurr)
     => ( v2227(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_49,axiom,
    ! [VarCurr] :
      ( ~ v2232(VarCurr)
     => ( v2231(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_51,axiom,
    ! [VarCurr] :
      ( v2232(VarCurr)
     => ( v2231(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_516,axiom,
    ! [VarCurr] :
      ( v2232(VarCurr)
    <=> ( v2233(VarCurr)
        | v2237(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_106,axiom,
    ! [VarCurr] :
      ( v2237(VarCurr)
    <=> ( v254(VarCurr,bitIndex9)
        & v2238(VarCurr) ) ) ).

fof(writeUnaryOperator_208,axiom,
    ! [VarCurr] :
      ( ~ v2238(VarCurr)
    <=> v110(VarCurr,bitIndex9) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_515,axiom,
    ! [VarCurr] :
      ( v2233(VarCurr)
    <=> ( v2234(VarCurr)
        | v2215(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_514,axiom,
    ! [VarCurr] :
      ( v2234(VarCurr)
    <=> ( v2235(VarCurr)
        | v2210(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_513,axiom,
    ! [VarCurr] :
      ( v2235(VarCurr)
    <=> ( v2236(VarCurr)
        | v610(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_512,axiom,
    ! [VarCurr] :
      ( v2236(VarCurr)
    <=> ( v108(VarCurr)
        | v2205(VarCurr) ) ) ).

fof(writeUnaryOperator_207,axiom,
    ! [VarCurr] :
      ( ~ v2230(VarCurr)
    <=> v102(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_511,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2221(VarNext)
      <=> v2222(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_510,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2222(VarNext)
      <=> ( v2223(VarNext)
          & v778(VarNext) ) ) ) ).

fof(writeUnaryOperator_206,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2223(VarNext)
      <=> v785(VarNext) ) ) ).

fof(writeBinaryOperatorShiftedRanges_105,axiom,
    ! [VarCurr] :
      ( v2215(VarCurr)
    <=> ( v254(VarCurr,bitIndex8)
        & v2217(VarCurr) ) ) ).

fof(writeUnaryOperator_205,axiom,
    ! [VarCurr] :
      ( ~ v2217(VarCurr)
    <=> v2218(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_104,axiom,
    ! [VarCurr] :
      ( v2218(VarCurr)
    <=> ( v110(VarCurr,bitIndex8)
        | v110(VarCurr,bitIndex9) ) ) ).

fof(writeBinaryOperatorShiftedRanges_103,axiom,
    ! [VarCurr] :
      ( v2210(VarCurr)
    <=> ( v254(VarCurr,bitIndex5)
        & v2212(VarCurr) ) ) ).

fof(writeUnaryOperator_204,axiom,
    ! [VarCurr] :
      ( ~ v2212(VarCurr)
    <=> v2213(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_102,axiom,
    ! [VarCurr] :
      ( v2213(VarCurr)
    <=> ( v110(VarCurr,bitIndex5)
        | v110(VarCurr,bitIndex9) ) ) ).

fof(writeBinaryOperatorShiftedRanges_101,axiom,
    ! [VarCurr] :
      ( v2205(VarCurr)
    <=> ( v254(VarCurr,bitIndex2)
        & v2207(VarCurr) ) ) ).

fof(writeUnaryOperator_203,axiom,
    ! [VarCurr] :
      ( ~ v2207(VarCurr)
    <=> v2208(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_100,axiom,
    ! [VarCurr] :
      ( v2208(VarCurr)
    <=> ( v110(VarCurr,bitIndex2)
        | v110(VarCurr,bitIndex9) ) ) ).

fof(addAssignment_481,axiom,
    ! [VarCurr] :
      ( v108(VarCurr)
    <=> v110(VarCurr,bitIndex3) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_14,axiom,
    ! [VarCurr] :
      ( ~ v2193(VarCurr)
     => ( v110(VarCurr,bitIndex3)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_12,axiom,
    ! [VarCurr] :
      ( v2193(VarCurr)
     => ( v110(VarCurr,bitIndex3)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_509,axiom,
    ! [VarCurr] :
      ( v2193(VarCurr)
    <=> ( v2194(VarCurr)
        | v2202(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_508,axiom,
    ! [VarCurr] :
      ( v2202(VarCurr)
    <=> ( v2203(VarCurr)
        & v2143(VarCurr) ) ) ).

fof(writeUnaryOperator_202,axiom,
    ! [VarCurr] :
      ( ~ v2203(VarCurr)
    <=> v112(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_507,axiom,
    ! [VarCurr] :
      ( v2194(VarCurr)
    <=> ( v2195(VarCurr)
        | v2200(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_506,axiom,
    ! [VarCurr] :
      ( v2200(VarCurr)
    <=> ( v2201(VarCurr)
        & v898(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_505,axiom,
    ! [VarCurr] :
      ( v2201(VarCurr)
    <=> ( v2141(VarCurr)
        & v980(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_504,axiom,
    ! [VarCurr] :
      ( v2195(VarCurr)
    <=> ( v2196(VarCurr)
        | v2198(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_503,axiom,
    ! [VarCurr] :
      ( v2198(VarCurr)
    <=> ( v2199(VarCurr)
        & v893(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_502,axiom,
    ! [VarCurr] :
      ( v2199(VarCurr)
    <=> ( v2141(VarCurr)
        & v980(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_501,axiom,
    ! [VarCurr] :
      ( v2196(VarCurr)
    <=> ( v2197(VarCurr)
        & v886(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_500,axiom,
    ! [VarCurr] :
      ( v2197(VarCurr)
    <=> ( v2141(VarCurr)
        & v980(VarCurr) ) ) ).

fof(addAssignment_480,axiom,
    ! [VarCurr] :
      ( v208(VarCurr)
    <=> v210(VarCurr) ) ).

fof(addAssignment_479,axiom,
    ! [VarCurr] :
      ( v210(VarCurr)
    <=> v212(VarCurr,bitIndex0) ) ).

fof(addAssignment_478,axiom,
    ! [VarCurr] :
      ( v212(VarCurr,bitIndex0)
    <=> v274(VarCurr,bitIndex0) ) ).

fof(addAssignment_477,axiom,
    ! [VarCurr] :
      ( v268(VarCurr,bitIndex0)
    <=> v272(VarCurr,bitIndex0) ) ).

fof(addAssignment_476,axiom,
    ! [VarCurr] :
      ( v261(VarCurr,bitIndex0)
    <=> v265(VarCurr,bitIndex0) ) ).

fof(writeUnaryOperator_201,axiom,
    ! [VarCurr] :
      ( ~ v214(VarCurr)
    <=> v2191(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_99,axiom,
    ! [VarCurr] :
      ( v2191(VarCurr)
    <=> ( v2153(VarCurr)
        | v216(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesMultipleBits_6,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v216(VarCurr,B)
      <=> ( v218(VarCurr,B)
          & v2103(VarCurr,B) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_17,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2166(VarNext)
       => ! [B] :
            ( range_2_0(B)
           => ( v2103(VarNext,B)
            <=> v2103(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_30,axiom,
    ! [VarNext] :
      ( v2166(VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v2103(VarNext,B)
          <=> v2185(VarNext,B) ) ) ) ).

fof(addAssignment_475,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_2_0(B)
         => ( v2185(VarNext,B)
          <=> v2183(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_19,axiom,
    ! [VarCurr] :
      ( ~ v2177(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v2183(VarCurr,B)
          <=> v2186(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_19,axiom,
    ! [VarCurr] :
      ( v2177(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v2183(VarCurr,B)
          <=> $true ) ) ) ).

fof(bitBlastConstant_227,axiom,
    b111(bitIndex2) ).

fof(bitBlastConstant_226,axiom,
    b111(bitIndex1) ).

fof(bitBlastConstant_225,axiom,
    b111(bitIndex0) ).

fof(addParallelCaseBooleanConditionEqualRanges1_18,axiom,
    ! [VarCurr] :
      ( ~ v2108(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v2186(VarCurr,B)
          <=> v263(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_18,axiom,
    ! [VarCurr] :
      ( v2108(VarCurr)
     => ! [B] :
          ( range_2_0(B)
         => ( v2186(VarCurr,B)
          <=> v270(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_499,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2166(VarNext)
      <=> ( v2167(VarNext)
          & v2176(VarNext) ) ) ) ).

fof(addAssignment_474,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2176(VarNext)
      <=> v2174(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_498,axiom,
    ! [VarCurr] :
      ( v2174(VarCurr)
    <=> ( v2177(VarCurr)
        | v2178(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_497,axiom,
    ! [VarCurr] :
      ( v2178(VarCurr)
    <=> ( v2179(VarCurr)
        & v2182(VarCurr) ) ) ).

fof(writeUnaryOperator_200,axiom,
    ! [VarCurr] :
      ( ~ v2182(VarCurr)
    <=> v2177(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_496,axiom,
    ! [VarCurr] :
      ( v2179(VarCurr)
    <=> ( v2108(VarCurr)
        | v2180(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_495,axiom,
    ! [VarCurr] :
      ( v2180(VarCurr)
    <=> ( v2156(VarCurr)
        & v2181(VarCurr) ) ) ).

fof(writeUnaryOperator_199,axiom,
    ! [VarCurr] :
      ( ~ v2181(VarCurr)
    <=> v2108(VarCurr) ) ).

fof(writeUnaryOperator_198,axiom,
    ! [VarCurr] :
      ( ~ v2177(VarCurr)
    <=> v2105(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_494,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2167(VarNext)
      <=> ( v2168(VarNext)
          & v2163(VarNext) ) ) ) ).

fof(writeUnaryOperator_197,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2168(VarNext)
      <=> v2170(VarNext) ) ) ).

fof(addAssignment_473,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2170(VarNext)
      <=> v2163(VarCurr) ) ) ).

fof(addAssignment_472,axiom,
    ! [VarCurr] :
      ( v2163(VarCurr)
    <=> v303(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_493,axiom,
    ! [VarCurr] :
      ( v2156(VarCurr)
    <=> ( v2158(VarCurr)
        & v2161(VarCurr) ) ) ).

fof(writeUnaryOperator_196,axiom,
    ! [VarCurr] :
      ( ~ v2161(VarCurr)
    <=> v2110(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_98,axiom,
    ! [VarCurr] :
      ( v2158(VarCurr)
    <=> ( v2160(VarCurr)
        | v218(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_97,axiom,
    ! [VarCurr] :
      ( v2160(VarCurr)
    <=> ( v218(VarCurr,bitIndex0)
        | v218(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_492,axiom,
    ! [VarCurr] :
      ( v2108(VarCurr)
    <=> ( v2151(VarCurr)
        & v2154(VarCurr) ) ) ).

fof(writeUnaryOperator_195,axiom,
    ! [VarCurr] :
      ( ~ v2154(VarCurr)
    <=> v2110(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_96,axiom,
    ! [VarCurr] :
      ( v2151(VarCurr)
    <=> ( v2153(VarCurr)
        | v216(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_95,axiom,
    ! [VarCurr] :
      ( v2153(VarCurr)
    <=> ( v216(VarCurr,bitIndex0)
        | v216(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_471,axiom,
    ! [VarCurr] :
      ( v2110(VarCurr)
    <=> v2112(VarCurr) ) ).

fof(addAssignment_470,axiom,
    ! [VarCurr] :
      ( v2112(VarCurr)
    <=> v2114(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_491,axiom,
    ! [VarCurr] :
      ( v2114(VarCurr)
    <=> ( v2145(VarCurr)
        | v112(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_94,axiom,
    ! [VarCurr] :
      ( v2145(VarCurr)
    <=> ( v2146(VarCurr)
        | v110(VarCurr,bitIndex11) ) ) ).

fof(writeBinaryOperatorShiftedRanges_93,axiom,
    ! [VarCurr] :
      ( v2146(VarCurr)
    <=> ( v2147(VarCurr)
        | v110(VarCurr,bitIndex10) ) ) ).

fof(writeBinaryOperatorShiftedRanges_92,axiom,
    ! [VarCurr] :
      ( v2147(VarCurr)
    <=> ( v2148(VarCurr)
        | v110(VarCurr,bitIndex9) ) ) ).

fof(writeBinaryOperatorShiftedRanges_91,axiom,
    ! [VarCurr] :
      ( v2148(VarCurr)
    <=> ( v2149(VarCurr)
        | v110(VarCurr,bitIndex8) ) ) ).

fof(writeBinaryOperatorShiftedRanges_90,axiom,
    ! [VarCurr] :
      ( v2149(VarCurr)
    <=> ( v110(VarCurr,bitIndex2)
        | v110(VarCurr,bitIndex5) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_13,axiom,
    ! [VarCurr] :
      ( ~ v2126(VarCurr)
     => ( v110(VarCurr,bitIndex10)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_11,axiom,
    ! [VarCurr] :
      ( v2126(VarCurr)
     => ( v110(VarCurr,bitIndex10)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_490,axiom,
    ! [VarCurr] :
      ( v2126(VarCurr)
    <=> ( v2127(VarCurr)
        | v2142(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_489,axiom,
    ! [VarCurr] :
      ( v2142(VarCurr)
    <=> ( v112(VarCurr)
        & v2143(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_103,axiom,
    ! [VarCurr] :
      ( v2143(VarCurr)
    <=> ( $true
      <=> v254(VarCurr,bitIndex10) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_488,axiom,
    ! [VarCurr] :
      ( v2127(VarCurr)
    <=> ( v2128(VarCurr)
        | v2138(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_487,axiom,
    ! [VarCurr] :
      ( v2138(VarCurr)
    <=> ( v2139(VarCurr)
        & v861(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_486,axiom,
    ! [VarCurr] :
      ( v2139(VarCurr)
    <=> ( v2141(VarCurr)
        & v980(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_485,axiom,
    ! [VarCurr] :
      ( v2141(VarCurr)
    <=> ( v976(VarCurr)
        & v510(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_484,axiom,
    ! [VarCurr] :
      ( v2128(VarCurr)
    <=> ( v2129(VarCurr)
        | v2136(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_483,axiom,
    ! [VarCurr] :
      ( v2136(VarCurr)
    <=> ( v2137(VarCurr)
        & v838(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_482,axiom,
    ! [VarCurr] :
      ( v2137(VarCurr)
    <=> ( v2133(VarCurr)
        & v980(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_481,axiom,
    ! [VarCurr] :
      ( v2129(VarCurr)
    <=> ( v2130(VarCurr)
        | v2134(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_480,axiom,
    ! [VarCurr] :
      ( v2134(VarCurr)
    <=> ( v2135(VarCurr)
        & v816(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_479,axiom,
    ! [VarCurr] :
      ( v2135(VarCurr)
    <=> ( v2133(VarCurr)
        & v980(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_478,axiom,
    ! [VarCurr] :
      ( v2130(VarCurr)
    <=> ( v2131(VarCurr)
        & v776(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_477,axiom,
    ! [VarCurr] :
      ( v2131(VarCurr)
    <=> ( v2133(VarCurr)
        & v980(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_476,axiom,
    ! [VarCurr] :
      ( v2133(VarCurr)
    <=> ( v988(VarCurr)
        & v510(VarCurr) ) ) ).

fof(addAssignment_469,axiom,
    ! [VarNext] :
      ( v254(VarNext,bitIndex10)
    <=> v2118(VarNext,bitIndex9) ) ).

fof(addCaseBooleanConditionShiftedRanges1_12,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2119(VarNext)
       => ( ( v2118(VarNext,bitIndex10)
          <=> v254(VarCurr,bitIndex11) )
          & ( v2118(VarNext,bitIndex9)
          <=> v254(VarCurr,bitIndex10) )
          & ( v2118(VarNext,bitIndex8)
          <=> v254(VarCurr,bitIndex9) )
          & ( v2118(VarNext,bitIndex7)
          <=> v254(VarCurr,bitIndex8) )
          & ( v2118(VarNext,bitIndex6)
          <=> v254(VarCurr,bitIndex7) )
          & ( v2118(VarNext,bitIndex5)
          <=> v254(VarCurr,bitIndex6) )
          & ( v2118(VarNext,bitIndex4)
          <=> v254(VarCurr,bitIndex5) )
          & ( v2118(VarNext,bitIndex3)
          <=> v254(VarCurr,bitIndex4) )
          & ( v2118(VarNext,bitIndex2)
          <=> v254(VarCurr,bitIndex3) )
          & ( v2118(VarNext,bitIndex1)
          <=> v254(VarCurr,bitIndex2) )
          & ( v2118(VarNext,bitIndex0)
          <=> v254(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_29,axiom,
    ! [VarNext] :
      ( v2119(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v2118(VarNext,B)
          <=> v791(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_475,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2119(VarNext)
      <=> v2120(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_474,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2120(VarNext)
      <=> ( v2122(VarNext)
          & v778(VarNext) ) ) ) ).

fof(writeUnaryOperator_194,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2122(VarNext)
      <=> v785(VarNext) ) ) ).

fof(addAssignment_468,axiom,
    ! [VarCurr] :
      ( v2105(VarCurr)
    <=> v104(VarCurr) ) ).

fof(addAssignment_467,axiom,
    ! [VarCurr] :
      ( v218(VarCurr,bitIndex0)
    <=> v2095(VarCurr) ) ).

fof(addAssignment_466,axiom,
    ! [VarCurr] :
      ( v218(VarCurr,bitIndex1)
    <=> v1298(VarCurr) ) ).

fof(addAssignment_465,axiom,
    ! [VarCurr] :
      ( v218(VarCurr,bitIndex2)
    <=> v220(VarCurr) ) ).

fof(addAssignment_464,axiom,
    ! [VarCurr] :
      ( v2095(VarCurr)
    <=> v2097(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_473,axiom,
    ! [VarCurr] :
      ( v2097(VarCurr)
    <=> ( v2099(VarCurr)
        & v2100(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_472,axiom,
    ! [VarCurr] :
      ( v2100(VarCurr)
    <=> ( v510(VarCurr)
        | v283(VarCurr) ) ) ).

fof(writeUnaryOperator_193,axiom,
    ! [VarCurr] :
      ( ~ v2099(VarCurr)
    <=> v373(VarCurr) ) ).

fof(addAssignment_463,axiom,
    ! [VarCurr] :
      ( v1298(VarCurr)
    <=> v1300(VarCurr) ) ).

fof(writeUnaryOperator_192,axiom,
    ! [VarCurr] :
      ( ~ v1300(VarCurr)
    <=> v1302(VarCurr) ) ).

fof(addAssignment_462,axiom,
    ! [VarCurr] :
      ( v1302(VarCurr)
    <=> v1304(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_471,axiom,
    ! [VarCurr] :
      ( v1304(VarCurr)
    <=> ( v1306(VarCurr)
        | v1995(VarCurr) ) ) ).

fof(addAssignment_461,axiom,
    ! [VarCurr] :
      ( v1995(VarCurr)
    <=> v1997(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_102,axiom,
    ! [VarCurr] :
      ( v1997(VarCurr)
    <=> ( ( v1999(VarCurr,bitIndex4)
        <=> $false )
        & ( v1999(VarCurr,bitIndex3)
        <=> $false )
        & ( v1999(VarCurr,bitIndex2)
        <=> $false )
        & ( v1999(VarCurr,bitIndex1)
        <=> $false )
        & ( v1999(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_16,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2079(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v1999(VarNext,B)
            <=> v1999(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_28,axiom,
    ! [VarNext] :
      ( v2079(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v1999(VarNext,B)
          <=> v2087(VarNext,B) ) ) ) ).

fof(addAssignment_460,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v2087(VarNext,B)
          <=> v2085(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_48,axiom,
    ! [VarCurr] :
      ( ~ v2088(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v2085(VarCurr,B)
          <=> v2001(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_50,axiom,
    ! [VarCurr] :
      ( v2088(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v2085(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_191,axiom,
    ! [VarCurr] :
      ( ~ v2088(VarCurr)
    <=> v535(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_470,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2079(VarNext)
      <=> v2080(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_469,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v2080(VarNext)
      <=> ( v2081(VarNext)
          & v532(VarNext) ) ) ) ).

fof(writeUnaryOperator_190,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v2081(VarNext)
      <=> v580(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_4,axiom,
    ! [VarCurr] :
      ( ( ~ v2003(VarCurr)
        & ~ v2005(VarCurr)
        & ~ v2046(VarCurr) )
     => ! [B] :
          ( range_4_0(B)
         => ( v2001(VarCurr,B)
          <=> v1999(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_7,axiom,
    ! [VarCurr] :
      ( v2046(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v2001(VarCurr,B)
          <=> v2048(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_17,axiom,
    ! [VarCurr] :
      ( v2005(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v2001(VarCurr,B)
          <=> v2007(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_17,axiom,
    ! [VarCurr] :
      ( v2003(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v2001(VarCurr,B)
          <=> v1999(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_101,axiom,
    ! [VarCurr] :
      ( v2075(VarCurr)
    <=> ( ( v2076(VarCurr,bitIndex1)
        <=> $true )
        & ( v2076(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_459,axiom,
    ! [VarCurr] :
      ( v2076(VarCurr,bitIndex0)
    <=> v604(VarCurr) ) ).

fof(addAssignment_458,axiom,
    ! [VarCurr] :
      ( v2076(VarCurr,bitIndex1)
    <=> v564(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_47,axiom,
    ! [VarCurr] :
      ( ~ v2049(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v2048(VarCurr,B)
          <=> v2050(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_49,axiom,
    ! [VarCurr] :
      ( v2049(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v2048(VarCurr,B)
          <=> b10000(B) ) ) ) ).

fof(addAssignment_457,axiom,
    ! [VarCurr] :
      ( v2050(VarCurr,bitIndex0)
    <=> v2072(VarCurr) ) ).

fof(addAssignment_456,axiom,
    ! [VarCurr] :
      ( v2050(VarCurr,bitIndex1)
    <=> v2070(VarCurr) ) ).

fof(addAssignment_455,axiom,
    ! [VarCurr] :
      ( v2050(VarCurr,bitIndex2)
    <=> v2065(VarCurr) ) ).

fof(addAssignment_454,axiom,
    ! [VarCurr] :
      ( v2050(VarCurr,bitIndex3)
    <=> v2060(VarCurr) ) ).

fof(addAssignment_453,axiom,
    ! [VarCurr] :
      ( v2050(VarCurr,bitIndex4)
    <=> v2052(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_468,axiom,
    ! [VarCurr] :
      ( v2070(VarCurr)
    <=> ( v2071(VarCurr)
        & v2074(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_89,axiom,
    ! [VarCurr] :
      ( v2074(VarCurr)
    <=> ( v1999(VarCurr,bitIndex0)
        | v1999(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_467,axiom,
    ! [VarCurr] :
      ( v2071(VarCurr)
    <=> ( v2072(VarCurr)
        | v2073(VarCurr) ) ) ).

fof(writeUnaryOperator_189,axiom,
    ! [VarCurr] :
      ( ~ v2073(VarCurr)
    <=> v1999(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_188,axiom,
    ! [VarCurr] :
      ( ~ v2072(VarCurr)
    <=> v1999(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_466,axiom,
    ! [VarCurr] :
      ( v2065(VarCurr)
    <=> ( v2066(VarCurr)
        & v2069(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_88,axiom,
    ! [VarCurr] :
      ( v2069(VarCurr)
    <=> ( v2057(VarCurr)
        | v1999(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_465,axiom,
    ! [VarCurr] :
      ( v2066(VarCurr)
    <=> ( v2067(VarCurr)
        | v2068(VarCurr) ) ) ).

fof(writeUnaryOperator_187,axiom,
    ! [VarCurr] :
      ( ~ v2068(VarCurr)
    <=> v1999(VarCurr,bitIndex2) ) ).

fof(writeUnaryOperator_186,axiom,
    ! [VarCurr] :
      ( ~ v2067(VarCurr)
    <=> v2057(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_464,axiom,
    ! [VarCurr] :
      ( v2060(VarCurr)
    <=> ( v2061(VarCurr)
        & v2064(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_87,axiom,
    ! [VarCurr] :
      ( v2064(VarCurr)
    <=> ( v2056(VarCurr)
        | v1999(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_463,axiom,
    ! [VarCurr] :
      ( v2061(VarCurr)
    <=> ( v2062(VarCurr)
        | v2063(VarCurr) ) ) ).

fof(writeUnaryOperator_185,axiom,
    ! [VarCurr] :
      ( ~ v2063(VarCurr)
    <=> v1999(VarCurr,bitIndex3) ) ).

fof(writeUnaryOperator_184,axiom,
    ! [VarCurr] :
      ( ~ v2062(VarCurr)
    <=> v2056(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_462,axiom,
    ! [VarCurr] :
      ( v2052(VarCurr)
    <=> ( v2053(VarCurr)
        & v2059(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_86,axiom,
    ! [VarCurr] :
      ( v2059(VarCurr)
    <=> ( v2055(VarCurr)
        | v1999(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_461,axiom,
    ! [VarCurr] :
      ( v2053(VarCurr)
    <=> ( v2054(VarCurr)
        | v2058(VarCurr) ) ) ).

fof(writeUnaryOperator_183,axiom,
    ! [VarCurr] :
      ( ~ v2058(VarCurr)
    <=> v1999(VarCurr,bitIndex4) ) ).

fof(writeUnaryOperator_182,axiom,
    ! [VarCurr] :
      ( ~ v2054(VarCurr)
    <=> v2055(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_85,axiom,
    ! [VarCurr] :
      ( v2055(VarCurr)
    <=> ( v2056(VarCurr)
        & v1999(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_84,axiom,
    ! [VarCurr] :
      ( v2056(VarCurr)
    <=> ( v2057(VarCurr)
        & v1999(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_83,axiom,
    ! [VarCurr] :
      ( v2057(VarCurr)
    <=> ( v1999(VarCurr,bitIndex0)
        & v1999(VarCurr,bitIndex1) ) ) ).

fof(addBitVectorEqualityBitBlasted_100,axiom,
    ! [VarCurr] :
      ( v2049(VarCurr)
    <=> ( ( v1999(VarCurr,bitIndex4)
        <=> $true )
        & ( v1999(VarCurr,bitIndex3)
        <=> $false )
        & ( v1999(VarCurr,bitIndex2)
        <=> $false )
        & ( v1999(VarCurr,bitIndex1)
        <=> $false )
        & ( v1999(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_99,axiom,
    ! [VarCurr] :
      ( v2046(VarCurr)
    <=> ( ( v2047(VarCurr,bitIndex1)
        <=> $true )
        & ( v2047(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_452,axiom,
    ! [VarCurr] :
      ( v2047(VarCurr,bitIndex0)
    <=> v604(VarCurr) ) ).

fof(addAssignment_451,axiom,
    ! [VarCurr] :
      ( v2047(VarCurr,bitIndex1)
    <=> v564(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_46,axiom,
    ! [VarCurr] :
      ( ~ v2008(VarCurr)
     => ! [B] :
          ( range_31_0(B)
         => ( v2007(VarCurr,B)
          <=> v2009(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_48,axiom,
    ! [VarCurr] :
      ( v2008(VarCurr)
     => ! [B] :
          ( range_31_0(B)
         => ( v2007(VarCurr,B)
          <=> $false ) ) ) ).

fof(addSignExtensionConstraint_78,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex6)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_77,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex7)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_76,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex8)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_75,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex9)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_74,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex10)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_73,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex11)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_72,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex12)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_71,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex13)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_70,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex14)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_69,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex15)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_68,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex16)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_67,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex17)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_66,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex18)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_65,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex19)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_64,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex20)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_63,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex21)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_62,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex22)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_61,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex23)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_60,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex24)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_59,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex25)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_58,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex26)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_57,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex27)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_56,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex28)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_55,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex29)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_54,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex30)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_53,axiom,
    ! [VarCurr] :
      ( v2009(VarCurr,bitIndex31)
    <=> v2010(VarCurr,bitIndex5) ) ).

fof(addAssignment_450,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v2009(VarCurr,B)
      <=> v2010(VarCurr,B) ) ) ).

fof(addAssignment_449,axiom,
    ! [VarCurr] :
      ( v2010(VarCurr,bitIndex0)
    <=> v2044(VarCurr) ) ).

fof(addAssignment_448,axiom,
    ! [VarCurr] :
      ( v2010(VarCurr,bitIndex1)
    <=> v2042(VarCurr) ) ).

fof(addAssignment_447,axiom,
    ! [VarCurr] :
      ( v2010(VarCurr,bitIndex2)
    <=> v2038(VarCurr) ) ).

fof(addAssignment_446,axiom,
    ! [VarCurr] :
      ( v2010(VarCurr,bitIndex3)
    <=> v2034(VarCurr) ) ).

fof(addAssignment_445,axiom,
    ! [VarCurr] :
      ( v2010(VarCurr,bitIndex4)
    <=> v2030(VarCurr) ) ).

fof(addAssignment_444,axiom,
    ! [VarCurr] :
      ( v2010(VarCurr,bitIndex5)
    <=> v2012(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_460,axiom,
    ! [VarCurr] :
      ( v2042(VarCurr)
    <=> ( v2043(VarCurr)
        & v2045(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_459,axiom,
    ! [VarCurr] :
      ( v2045(VarCurr)
    <=> ( v2016(VarCurr,bitIndex0)
        | v2024(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_82,axiom,
    ! [VarCurr] :
      ( v2043(VarCurr)
    <=> ( v2044(VarCurr)
        | v2016(VarCurr,bitIndex1) ) ) ).

fof(writeUnaryOperator_181,axiom,
    ! [VarCurr] :
      ( ~ v2044(VarCurr)
    <=> v2016(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_458,axiom,
    ! [VarCurr] :
      ( v2038(VarCurr)
    <=> ( v2039(VarCurr)
        & v2041(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_457,axiom,
    ! [VarCurr] :
      ( v2041(VarCurr)
    <=> ( v2022(VarCurr)
        | v2025(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_81,axiom,
    ! [VarCurr] :
      ( v2039(VarCurr)
    <=> ( v2040(VarCurr)
        | v2016(VarCurr,bitIndex2) ) ) ).

fof(writeUnaryOperator_180,axiom,
    ! [VarCurr] :
      ( ~ v2040(VarCurr)
    <=> v2022(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_456,axiom,
    ! [VarCurr] :
      ( v2034(VarCurr)
    <=> ( v2035(VarCurr)
        & v2037(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_455,axiom,
    ! [VarCurr] :
      ( v2037(VarCurr)
    <=> ( v2020(VarCurr)
        | v2026(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_80,axiom,
    ! [VarCurr] :
      ( v2035(VarCurr)
    <=> ( v2036(VarCurr)
        | v2016(VarCurr,bitIndex3) ) ) ).

fof(writeUnaryOperator_179,axiom,
    ! [VarCurr] :
      ( ~ v2036(VarCurr)
    <=> v2020(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_454,axiom,
    ! [VarCurr] :
      ( v2030(VarCurr)
    <=> ( v2031(VarCurr)
        & v2033(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_453,axiom,
    ! [VarCurr] :
      ( v2033(VarCurr)
    <=> ( v2018(VarCurr)
        | v2027(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_79,axiom,
    ! [VarCurr] :
      ( v2031(VarCurr)
    <=> ( v2032(VarCurr)
        | v2016(VarCurr,bitIndex4) ) ) ).

fof(writeUnaryOperator_178,axiom,
    ! [VarCurr] :
      ( ~ v2032(VarCurr)
    <=> v2018(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_452,axiom,
    ! [VarCurr] :
      ( v2012(VarCurr)
    <=> ( v2013(VarCurr)
        & v2028(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_451,axiom,
    ! [VarCurr] :
      ( v2028(VarCurr)
    <=> ( v2015(VarCurr)
        | v2029(VarCurr) ) ) ).

fof(writeUnaryOperator_177,axiom,
    ! [VarCurr] :
      ( ~ v2029(VarCurr)
    <=> v2016(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_78,axiom,
    ! [VarCurr] :
      ( v2013(VarCurr)
    <=> ( v2014(VarCurr)
        | v2016(VarCurr,bitIndex5) ) ) ).

fof(writeUnaryOperator_176,axiom,
    ! [VarCurr] :
      ( ~ v2014(VarCurr)
    <=> v2015(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_77,axiom,
    ! [VarCurr] :
      ( v2015(VarCurr)
    <=> ( v2016(VarCurr,bitIndex4)
        | v2017(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_450,axiom,
    ! [VarCurr] :
      ( v2017(VarCurr)
    <=> ( v2018(VarCurr)
        & v2027(VarCurr) ) ) ).

fof(writeUnaryOperator_175,axiom,
    ! [VarCurr] :
      ( ~ v2027(VarCurr)
    <=> v2016(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_76,axiom,
    ! [VarCurr] :
      ( v2018(VarCurr)
    <=> ( v2016(VarCurr,bitIndex3)
        | v2019(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_449,axiom,
    ! [VarCurr] :
      ( v2019(VarCurr)
    <=> ( v2020(VarCurr)
        & v2026(VarCurr) ) ) ).

fof(writeUnaryOperator_174,axiom,
    ! [VarCurr] :
      ( ~ v2026(VarCurr)
    <=> v2016(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_75,axiom,
    ! [VarCurr] :
      ( v2020(VarCurr)
    <=> ( v2016(VarCurr,bitIndex2)
        | v2021(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_448,axiom,
    ! [VarCurr] :
      ( v2021(VarCurr)
    <=> ( v2022(VarCurr)
        & v2025(VarCurr) ) ) ).

fof(writeUnaryOperator_173,axiom,
    ! [VarCurr] :
      ( ~ v2025(VarCurr)
    <=> v2016(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges_74,axiom,
    ! [VarCurr] :
      ( v2022(VarCurr)
    <=> ( v2016(VarCurr,bitIndex1)
        | v2023(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_447,axiom,
    ! [VarCurr] :
      ( v2023(VarCurr)
    <=> ( v2016(VarCurr,bitIndex0)
        & v2024(VarCurr) ) ) ).

fof(writeUnaryOperator_172,axiom,
    ! [VarCurr] :
      ( ~ v2024(VarCurr)
    <=> v2016(VarCurr,bitIndex1) ) ).

fof(addZeroExtensionConstraint_2,axiom,
    ! [VarCurr] : ~ v2016(VarCurr,bitIndex5) ).

fof(addAssignment_443,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v2016(VarCurr,B)
      <=> v1999(VarCurr,B) ) ) ).

fof(addBitVectorEqualityBitBlasted_98,axiom,
    ! [VarCurr] :
      ( v2008(VarCurr)
    <=> ( ( v1999(VarCurr,bitIndex4)
        <=> $false )
        & ( v1999(VarCurr,bitIndex3)
        <=> $false )
        & ( v1999(VarCurr,bitIndex2)
        <=> $false )
        & ( v1999(VarCurr,bitIndex1)
        <=> $false )
        & ( v1999(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_97,axiom,
    ! [VarCurr] :
      ( v2005(VarCurr)
    <=> ( ( v2006(VarCurr,bitIndex1)
        <=> $false )
        & ( v2006(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_442,axiom,
    ! [VarCurr] :
      ( v2006(VarCurr,bitIndex0)
    <=> v604(VarCurr) ) ).

fof(addAssignment_441,axiom,
    ! [VarCurr] :
      ( v2006(VarCurr,bitIndex1)
    <=> v564(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_96,axiom,
    ! [VarCurr] :
      ( v2003(VarCurr)
    <=> ( ( v2004(VarCurr,bitIndex1)
        <=> $false )
        & ( v2004(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_440,axiom,
    ! [VarCurr] :
      ( v2004(VarCurr,bitIndex0)
    <=> v604(VarCurr) ) ).

fof(addAssignment_439,axiom,
    ! [VarCurr] :
      ( v2004(VarCurr,bitIndex1)
    <=> v564(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_446,axiom,
    ! [VarCurr] :
      ( v1306(VarCurr)
    <=> ( v1989(VarCurr)
        | v1993(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_445,axiom,
    ! [VarCurr] :
      ( v1993(VarCurr)
    <=> ( v1905(VarCurr)
        & v1911(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_444,axiom,
    ! [VarCurr] :
      ( v1989(VarCurr)
    <=> ( v1990(VarCurr)
        | v1602(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_443,axiom,
    ! [VarCurr] :
      ( v1990(VarCurr)
    <=> ( v1991(VarCurr)
        & v1992(VarCurr) ) ) ).

fof(writeUnaryOperator_171,axiom,
    ! [VarCurr] :
      ( ~ v1992(VarCurr)
    <=> v1425(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_442,axiom,
    ! [VarCurr] :
      ( v1991(VarCurr)
    <=> ( v1308(VarCurr)
        & v1353(VarCurr) ) ) ).

fof(addAssignment_438,axiom,
    ! [VarCurr] :
      ( v1911(VarCurr)
    <=> v1913(VarCurr) ) ).

fof(addAssignment_437,axiom,
    ! [VarCurr] :
      ( v1913(VarCurr)
    <=> v1915(VarCurr) ) ).

fof(addAssignment_436,axiom,
    ! [VarCurr] :
      ( v1915(VarCurr)
    <=> v1917(VarCurr) ) ).

fof(addAssignment_435,axiom,
    ! [VarCurr] :
      ( v1917(VarCurr)
    <=> v1919(VarCurr) ) ).

fof(addAssignment_434,axiom,
    ! [VarCurr] :
      ( v1919(VarCurr)
    <=> v1435(VarCurr,bitIndex1) ) ).

fof(addAssignment_433,axiom,
    ! [VarCurr] :
      ( v1435(VarCurr,bitIndex1)
    <=> v1437(VarCurr,bitIndex1) ) ).

fof(addAssignment_432,axiom,
    ! [VarCurr] :
      ( v1437(VarCurr,bitIndex1)
    <=> v1439(VarCurr,bitIndex1) ) ).

fof(addAssignment_431,axiom,
    ! [VarCurr] :
      ( v1439(VarCurr,bitIndex1)
    <=> v1441(VarCurr,bitIndex1) ) ).

fof(addAssignment_430,axiom,
    ! [VarCurr] :
      ( v1441(VarCurr,bitIndex1)
    <=> v1443(VarCurr,bitIndex1) ) ).

fof(addAssignment_429,axiom,
    ! [VarCurr] :
      ( v1443(VarCurr,bitIndex1)
    <=> v1445(VarCurr,bitIndex1) ) ).

fof(addAssignment_428,axiom,
    ! [VarCurr] :
      ( v1445(VarCurr,bitIndex1)
    <=> v1921(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_15,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1944(VarNext)
       => ( v1921(VarNext)
        <=> v1921(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_27,axiom,
    ! [VarNext] :
      ( v1944(VarNext)
     => ( v1921(VarNext)
      <=> v1979(VarNext) ) ) ).

fof(addAssignment_427,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1979(VarNext)
      <=> v1977(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_16,axiom,
    ! [VarCurr] :
      ( ~ v1923(VarCurr)
     => ( v1977(VarCurr)
      <=> v1980(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_16,axiom,
    ! [VarCurr] :
      ( v1923(VarCurr)
     => ( v1977(VarCurr)
      <=> v1925(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_15,axiom,
    ! [VarCurr] :
      ( ~ v1957(VarCurr)
     => ( v1980(VarCurr)
      <=> v1939(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_15,axiom,
    ! [VarCurr] :
      ( v1957(VarCurr)
     => ( v1980(VarCurr)
      <=> v1981(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_6,axiom,
    ! [VarCurr] :
      ( ( ~ v1960(VarCurr)
        & ~ v1962(VarCurr) )
     => ( v1981(VarCurr)
      <=> v1985(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_14,axiom,
    ! [VarCurr] :
      ( v1962(VarCurr)
     => ( v1981(VarCurr)
      <=> v1984(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_14,axiom,
    ! [VarCurr] :
      ( v1960(VarCurr)
     => ( v1981(VarCurr)
      <=> v1982(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_13,axiom,
    ! [VarCurr] :
      ( ~ v1970(VarCurr)
     => ( v1985(VarCurr)
      <=> v1939(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_13,axiom,
    ! [VarCurr] :
      ( v1970(VarCurr)
     => ( v1985(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_12,axiom,
    ! [VarCurr] :
      ( ~ v1964(VarCurr)
     => ( v1984(VarCurr)
      <=> v1939(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_12,axiom,
    ! [VarCurr] :
      ( v1964(VarCurr)
     => ( v1984(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_45,axiom,
    ! [VarCurr] :
      ( ~ v1983(VarCurr)
     => ( v1982(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_47,axiom,
    ! [VarCurr] :
      ( v1983(VarCurr)
     => ( v1982(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_95,axiom,
    ! [VarCurr] :
      ( v1983(VarCurr)
    <=> ( v1933(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_441,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1944(VarNext)
      <=> ( v1945(VarNext)
          & v1954(VarNext) ) ) ) ).

fof(addAssignment_426,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1954(VarNext)
      <=> v1952(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_440,axiom,
    ! [VarCurr] :
      ( v1952(VarCurr)
    <=> ( v1923(VarCurr)
        | v1955(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_439,axiom,
    ! [VarCurr] :
      ( v1955(VarCurr)
    <=> ( v1956(VarCurr)
        & v1976(VarCurr) ) ) ).

fof(writeUnaryOperator_170,axiom,
    ! [VarCurr] :
      ( ~ v1976(VarCurr)
    <=> v1923(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_438,axiom,
    ! [VarCurr] :
      ( v1956(VarCurr)
    <=> ( v1957(VarCurr)
        | v1974(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_437,axiom,
    ! [VarCurr] :
      ( v1974(VarCurr)
    <=> ( v1935(VarCurr)
        & v1975(VarCurr) ) ) ).

fof(writeUnaryOperator_169,axiom,
    ! [VarCurr] :
      ( ~ v1975(VarCurr)
    <=> v1937(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_436,axiom,
    ! [VarCurr] :
      ( v1957(VarCurr)
    <=> ( v1958(VarCurr)
        & v1937(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_435,axiom,
    ! [VarCurr] :
      ( v1958(VarCurr)
    <=> ( v1959(VarCurr)
        | v1968(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_434,axiom,
    ! [VarCurr] :
      ( v1968(VarCurr)
    <=> ( v1969(VarCurr)
        & v1973(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_94,axiom,
    ! [VarCurr] :
      ( v1973(VarCurr)
    <=> ( ( v1961(VarCurr,bitIndex2)
        <=> $false )
        & ( v1961(VarCurr,bitIndex1)
        <=> $false )
        & ( v1961(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_433,axiom,
    ! [VarCurr] :
      ( v1969(VarCurr)
    <=> ( v1970(VarCurr)
        | v1971(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_432,axiom,
    ! [VarCurr] :
      ( v1971(VarCurr)
    <=> ( v1935(VarCurr)
        & v1972(VarCurr) ) ) ).

fof(writeUnaryOperator_168,axiom,
    ! [VarCurr] :
      ( ~ v1972(VarCurr)
    <=> v1970(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_93,axiom,
    ! [VarCurr] :
      ( v1970(VarCurr)
    <=> ( v1933(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_431,axiom,
    ! [VarCurr] :
      ( v1959(VarCurr)
    <=> ( v1960(VarCurr)
        | v1962(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_430,axiom,
    ! [VarCurr] :
      ( v1962(VarCurr)
    <=> ( v1963(VarCurr)
        & v1967(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_92,axiom,
    ! [VarCurr] :
      ( v1967(VarCurr)
    <=> ( ( v1961(VarCurr,bitIndex2)
        <=> $false )
        & ( v1961(VarCurr,bitIndex1)
        <=> $true )
        & ( v1961(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_429,axiom,
    ! [VarCurr] :
      ( v1963(VarCurr)
    <=> ( v1964(VarCurr)
        | v1965(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_428,axiom,
    ! [VarCurr] :
      ( v1965(VarCurr)
    <=> ( v1935(VarCurr)
        & v1966(VarCurr) ) ) ).

fof(writeUnaryOperator_167,axiom,
    ! [VarCurr] :
      ( ~ v1966(VarCurr)
    <=> v1964(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_91,axiom,
    ! [VarCurr] :
      ( v1964(VarCurr)
    <=> ( v1933(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_90,axiom,
    ! [VarCurr] :
      ( v1960(VarCurr)
    <=> ( ( v1961(VarCurr,bitIndex2)
        <=> $true )
        & ( v1961(VarCurr,bitIndex1)
        <=> $false )
        & ( v1961(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_425,axiom,
    ! [VarCurr] :
      ( v1961(VarCurr,bitIndex0)
    <=> v1931(VarCurr) ) ).

fof(addAssignment_424,axiom,
    ! [VarCurr] :
      ( v1961(VarCurr,bitIndex1)
    <=> v1929(VarCurr) ) ).

fof(addAssignment_423,axiom,
    ! [VarCurr] :
      ( v1961(VarCurr,bitIndex2)
    <=> v1927(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_427,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1945(VarNext)
      <=> ( v1946(VarNext)
          & v1941(VarNext) ) ) ) ).

fof(writeUnaryOperator_166,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1946(VarNext)
      <=> v1948(VarNext) ) ) ).

fof(addAssignment_422,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1948(VarNext)
      <=> v1941(VarCurr) ) ) ).

fof(addAssignment_421,axiom,
    ! [VarCurr] :
      ( v1941(VarCurr)
    <=> v1544(VarCurr) ) ).

fof(addAssignment_420,axiom,
    ! [VarCurr] :
      ( v1939(VarCurr)
    <=> $false ) ).

fof(addAssignment_419,axiom,
    ! [VarCurr] :
      ( v1937(VarCurr)
    <=> v1507(VarCurr) ) ).

fof(addAssignment_418,axiom,
    ! [VarCurr] :
      ( v1935(VarCurr)
    <=> $false ) ).

fof(addAssignment_417,axiom,
    ! [VarCurr] :
      ( v1933(VarCurr)
    <=> v1483(VarCurr,bitIndex1) ) ).

fof(addAssignment_416,axiom,
    ! [VarCurr] :
      ( v1483(VarCurr,bitIndex1)
    <=> v1485(VarCurr,bitIndex1) ) ).

fof(addAssignment_415,axiom,
    ! [VarCurr] :
      ( v1485(VarCurr,bitIndex1)
    <=> v1487(VarCurr,bitIndex1) ) ).

fof(addAssignment_414,axiom,
    ! [VarCurr] :
      ( v1487(VarCurr,bitIndex1)
    <=> v1489(VarCurr,bitIndex1) ) ).

fof(addAssignment_413,axiom,
    ! [VarCurr] :
      ( v1489(VarCurr,bitIndex1)
    <=> v1491(VarCurr,bitIndex1) ) ).

fof(addAssignment_412,axiom,
    ! [VarCurr] :
      ( v1491(VarCurr,bitIndex1)
    <=> v1493(VarCurr,bitIndex1) ) ).

fof(addAssignment_411,axiom,
    ! [VarCurr] :
      ( v1493(VarCurr,bitIndex1)
    <=> v1495(VarCurr,bitIndex1) ) ).

fof(addAssignment_410,axiom,
    ! [VarCurr] :
      ( v1495(VarCurr,bitIndex1)
    <=> v1497(VarCurr,bitIndex1) ) ).

fof(addAssignment_409,axiom,
    ! [VarCurr] :
      ( v1497(VarCurr,bitIndex1)
    <=> v1499(VarCurr,bitIndex1) ) ).

fof(addAssignment_408,axiom,
    ! [VarCurr] :
      ( v1931(VarCurr)
    <=> $false ) ).

fof(addAssignment_407,axiom,
    ! [VarCurr] :
      ( v1929(VarCurr)
    <=> $false ) ).

fof(addAssignment_406,axiom,
    ! [VarCurr] :
      ( v1927(VarCurr)
    <=> $true ) ).

fof(addAssignment_405,axiom,
    ! [VarCurr] :
      ( v1925(VarCurr)
    <=> $false ) ).

fof(addAssignment_404,axiom,
    ! [VarCurr] :
      ( v1923(VarCurr)
    <=> v1451(VarCurr) ) ).

fof(addAssignment_403,axiom,
    ! [VarCurr] :
      ( v1905(VarCurr)
    <=> v1907(VarCurr) ) ).

fof(addAssignment_402,axiom,
    ! [VarCurr] :
      ( v1907(VarCurr)
    <=> v1909(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_426,axiom,
    ! [VarCurr] :
      ( v1602(VarCurr)
    <=> ( v1896(VarCurr)
        & v1425(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_425,axiom,
    ! [VarCurr] :
      ( v1896(VarCurr)
    <=> ( v1897(VarCurr)
        | v1900(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_424,axiom,
    ! [VarCurr] :
      ( v1900(VarCurr)
    <=> ( v1901(VarCurr)
        & v1902(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_89,axiom,
    ! [VarCurr] :
      ( v1902(VarCurr)
    <=> ( ( v1903(VarCurr,bitIndex4)
        <=> $true )
        & ( v1903(VarCurr,bitIndex3)
        <=> $true )
        & ( v1903(VarCurr,bitIndex2)
        <=> $true )
        & ( v1903(VarCurr,bitIndex1)
        <=> $true )
        & ( v1903(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_401,axiom,
    ! [VarCurr] :
      ( v1903(VarCurr,bitIndex0)
    <=> v1856(VarCurr) ) ).

fof(addAssignment_400,axiom,
    ! [VarCurr] :
      ( v1903(VarCurr,bitIndex1)
    <=> v1851(VarCurr) ) ).

fof(addAssignment_399,axiom,
    ! [VarCurr] :
      ( v1903(VarCurr,bitIndex2)
    <=> v1846(VarCurr) ) ).

fof(addAssignment_398,axiom,
    ! [VarCurr] :
      ( v1903(VarCurr,bitIndex3)
    <=> v1841(VarCurr) ) ).

fof(addAssignment_397,axiom,
    ! [VarCurr] :
      ( v1903(VarCurr,bitIndex4)
    <=> v1814(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_88,axiom,
    ! [VarCurr] :
      ( v1901(VarCurr)
    <=> ( ( v1604(VarCurr,bitIndex1)
        <=> $true )
        & ( v1604(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_423,axiom,
    ! [VarCurr] :
      ( v1897(VarCurr)
    <=> ( v1898(VarCurr)
        | v1899(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_87,axiom,
    ! [VarCurr] :
      ( v1899(VarCurr)
    <=> ( ( v1604(VarCurr,bitIndex1)
        <=> $true )
        & ( v1604(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_86,axiom,
    ! [VarCurr] :
      ( v1898(VarCurr)
    <=> ( ( v1604(VarCurr,bitIndex1)
        <=> $false )
        & ( v1604(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_14,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1881(VarNext)
       => ! [B] :
            ( range_1_0(B)
           => ( v1604(VarNext,B)
            <=> v1604(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_26,axiom,
    ! [VarNext] :
      ( v1881(VarNext)
     => ! [B] :
          ( range_1_0(B)
         => ( v1604(VarNext,B)
          <=> v1889(VarNext,B) ) ) ) ).

fof(addAssignment_396,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_1_0(B)
         => ( v1889(VarNext,B)
          <=> v1887(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_44,axiom,
    ! [VarCurr] :
      ( ~ v1890(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1887(VarCurr,B)
          <=> v1606(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_46,axiom,
    ! [VarCurr] :
      ( v1890(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1887(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_422,axiom,
    ! [VarCurr] :
      ( v1890(VarCurr)
    <=> ( v1891(VarCurr)
        | v1892(VarCurr) ) ) ).

fof(writeUnaryOperator_165,axiom,
    ! [VarCurr] :
      ( ~ v1892(VarCurr)
    <=> v1425(VarCurr) ) ).

fof(writeUnaryOperator_164,axiom,
    ! [VarCurr] :
      ( ~ v1891(VarCurr)
    <=> v104(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_421,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1881(VarNext)
      <=> v1882(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_420,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1882(VarNext)
      <=> ( v1883(VarNext)
          & v303(VarNext) ) ) ) ).

fof(writeUnaryOperator_163,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1883(VarNext)
      <=> v1408(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_3,axiom,
    ! [VarCurr] :
      ( ( ~ v1790(VarCurr)
        & ~ v1794(VarCurr)
        & ~ v1806(VarCurr) )
     => ! [B] :
          ( range_1_0(B)
         => ( v1606(VarCurr,B)
          <=> v1860(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_5,axiom,
    ! [VarCurr] :
      ( v1806(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1606(VarCurr,B)
          <=> v1807(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_11,axiom,
    ! [VarCurr] :
      ( v1794(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1606(VarCurr,B)
          <=> v1795(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_11,axiom,
    ! [VarCurr] :
      ( v1790(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1606(VarCurr,B)
          <=> v1791(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_43,axiom,
    ! [VarCurr] :
      ( ~ v1396(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1860(VarCurr,B)
          <=> v1861(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_45,axiom,
    ! [VarCurr] :
      ( v1396(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1860(VarCurr,B)
          <=> b01(B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_42,axiom,
    ! [VarCurr] :
      ( ~ v1862(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1861(VarCurr,B)
          <=> v1863(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_44,axiom,
    ! [VarCurr] :
      ( v1862(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1861(VarCurr,B)
          <=> $false ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_41,axiom,
    ! [VarCurr] :
      ( ~ v1864(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1863(VarCurr,B)
          <=> $true ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_43,axiom,
    ! [VarCurr] :
      ( v1864(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1863(VarCurr,B)
          <=> b10(B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_419,axiom,
    ! [VarCurr] :
      ( v1864(VarCurr)
    <=> ( v1866(VarCurr)
        | v1868(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_73,axiom,
    ! [VarCurr] :
      ( v1868(VarCurr)
    <=> ( v1869(VarCurr)
        & v1867(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_418,axiom,
    ! [VarCurr] :
      ( v1869(VarCurr)
    <=> ( v1870(VarCurr)
        | v1871(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_72,axiom,
    ! [VarCurr] :
      ( v1871(VarCurr)
    <=> ( v1872(VarCurr)
        & v1867(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_417,axiom,
    ! [VarCurr] :
      ( v1872(VarCurr)
    <=> ( v1873(VarCurr)
        | v1874(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_71,axiom,
    ! [VarCurr] :
      ( v1874(VarCurr)
    <=> ( v1875(VarCurr)
        & v1867(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_416,axiom,
    ! [VarCurr] :
      ( v1875(VarCurr)
    <=> ( v1876(VarCurr)
        | v1877(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_70,axiom,
    ! [VarCurr] :
      ( v1877(VarCurr)
    <=> ( v1878(VarCurr)
        & v1867(VarCurr,bitIndex1) ) ) ).

fof(writeUnaryOperator_162,axiom,
    ! [VarCurr] :
      ( ~ v1878(VarCurr)
    <=> v1867(VarCurr,bitIndex0) ) ).

fof(writeUnaryOperator_161,axiom,
    ! [VarCurr] :
      ( ~ v1876(VarCurr)
    <=> v1867(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_160,axiom,
    ! [VarCurr] :
      ( ~ v1873(VarCurr)
    <=> v1867(VarCurr,bitIndex2) ) ).

fof(writeUnaryOperator_159,axiom,
    ! [VarCurr] :
      ( ~ v1870(VarCurr)
    <=> v1867(VarCurr,bitIndex3) ) ).

fof(writeUnaryOperator_158,axiom,
    ! [VarCurr] :
      ( ~ v1866(VarCurr)
    <=> v1867(VarCurr,bitIndex4) ) ).

fof(addAssignment_395,axiom,
    ! [VarCurr] :
      ( v1867(VarCurr,bitIndex0)
    <=> v1856(VarCurr) ) ).

fof(addAssignment_394,axiom,
    ! [VarCurr] :
      ( v1867(VarCurr,bitIndex1)
    <=> v1851(VarCurr) ) ).

fof(addAssignment_393,axiom,
    ! [VarCurr] :
      ( v1867(VarCurr,bitIndex2)
    <=> v1846(VarCurr) ) ).

fof(addAssignment_392,axiom,
    ! [VarCurr] :
      ( v1867(VarCurr,bitIndex3)
    <=> v1841(VarCurr) ) ).

fof(addAssignment_391,axiom,
    ! [VarCurr] :
      ( v1867(VarCurr,bitIndex4)
    <=> v1814(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_85,axiom,
    ! [VarCurr] :
      ( v1862(VarCurr)
    <=> ( ( v1634(VarCurr,bitIndex4)
        <=> $false )
        & ( v1634(VarCurr,bitIndex3)
        <=> $false )
        & ( v1634(VarCurr,bitIndex2)
        <=> $false )
        & ( v1634(VarCurr,bitIndex1)
        <=> $false )
        & ( v1634(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_84,axiom,
    ! [VarCurr] :
      ( v1859(VarCurr)
    <=> ( ( v1604(VarCurr,bitIndex1)
        <=> $true )
        & ( v1604(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_40,axiom,
    ! [VarCurr] :
      ( ~ v1396(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1807(VarCurr,B)
          <=> v1808(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_42,axiom,
    ! [VarCurr] :
      ( v1396(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1807(VarCurr,B)
          <=> b01(B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_39,axiom,
    ! [VarCurr] :
      ( ~ v1809(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1808(VarCurr,B)
          <=> v1810(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_41,axiom,
    ! [VarCurr] :
      ( v1809(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1808(VarCurr,B)
          <=> $false ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_38,axiom,
    ! [VarCurr] :
      ( ~ v1811(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1810(VarCurr,B)
          <=> b10(B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_40,axiom,
    ! [VarCurr] :
      ( v1811(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1810(VarCurr,B)
          <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_83,axiom,
    ! [VarCurr] :
      ( v1811(VarCurr)
    <=> ( ( v1812(VarCurr,bitIndex4)
        <=> $true )
        & ( v1812(VarCurr,bitIndex3)
        <=> $true )
        & ( v1812(VarCurr,bitIndex2)
        <=> $true )
        & ( v1812(VarCurr,bitIndex1)
        <=> $true )
        & ( v1812(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_224,axiom,
    b11111(bitIndex4) ).

fof(bitBlastConstant_223,axiom,
    b11111(bitIndex3) ).

fof(bitBlastConstant_222,axiom,
    b11111(bitIndex2) ).

fof(bitBlastConstant_221,axiom,
    b11111(bitIndex1) ).

fof(bitBlastConstant_220,axiom,
    b11111(bitIndex0) ).

fof(addAssignment_390,axiom,
    ! [VarCurr] :
      ( v1812(VarCurr,bitIndex0)
    <=> v1856(VarCurr) ) ).

fof(addAssignment_389,axiom,
    ! [VarCurr] :
      ( v1812(VarCurr,bitIndex1)
    <=> v1851(VarCurr) ) ).

fof(addAssignment_388,axiom,
    ! [VarCurr] :
      ( v1812(VarCurr,bitIndex2)
    <=> v1846(VarCurr) ) ).

fof(addAssignment_387,axiom,
    ! [VarCurr] :
      ( v1812(VarCurr,bitIndex3)
    <=> v1841(VarCurr) ) ).

fof(addAssignment_386,axiom,
    ! [VarCurr] :
      ( v1812(VarCurr,bitIndex4)
    <=> v1814(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_415,axiom,
    ! [VarCurr] :
      ( v1856(VarCurr)
    <=> ( v1857(VarCurr)
        & v1858(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_414,axiom,
    ! [VarCurr] :
      ( v1858(VarCurr)
    <=> ( v1634(VarCurr,bitIndex0)
        | v1729(VarCurr,bitIndex0) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_413,axiom,
    ! [VarCurr] :
      ( v1857(VarCurr)
    <=> ( v1700(VarCurr)
        | v1783(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_412,axiom,
    ! [VarCurr] :
      ( v1851(VarCurr)
    <=> ( v1852(VarCurr)
        & v1855(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_411,axiom,
    ! [VarCurr] :
      ( v1855(VarCurr)
    <=> ( v1823(VarCurr)
        | v1824(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_410,axiom,
    ! [VarCurr] :
      ( v1852(VarCurr)
    <=> ( v1853(VarCurr)
        | v1854(VarCurr) ) ) ).

fof(writeUnaryOperator_157,axiom,
    ! [VarCurr] :
      ( ~ v1854(VarCurr)
    <=> v1824(VarCurr) ) ).

fof(writeUnaryOperator_156,axiom,
    ! [VarCurr] :
      ( ~ v1853(VarCurr)
    <=> v1823(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_409,axiom,
    ! [VarCurr] :
      ( v1846(VarCurr)
    <=> ( v1847(VarCurr)
        & v1850(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_408,axiom,
    ! [VarCurr] :
      ( v1850(VarCurr)
    <=> ( v1821(VarCurr)
        | v1828(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_407,axiom,
    ! [VarCurr] :
      ( v1847(VarCurr)
    <=> ( v1848(VarCurr)
        | v1849(VarCurr) ) ) ).

fof(writeUnaryOperator_155,axiom,
    ! [VarCurr] :
      ( ~ v1849(VarCurr)
    <=> v1828(VarCurr) ) ).

fof(writeUnaryOperator_154,axiom,
    ! [VarCurr] :
      ( ~ v1848(VarCurr)
    <=> v1821(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_406,axiom,
    ! [VarCurr] :
      ( v1841(VarCurr)
    <=> ( v1842(VarCurr)
        & v1845(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_405,axiom,
    ! [VarCurr] :
      ( v1845(VarCurr)
    <=> ( v1819(VarCurr)
        | v1832(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_404,axiom,
    ! [VarCurr] :
      ( v1842(VarCurr)
    <=> ( v1843(VarCurr)
        | v1844(VarCurr) ) ) ).

fof(writeUnaryOperator_153,axiom,
    ! [VarCurr] :
      ( ~ v1844(VarCurr)
    <=> v1832(VarCurr) ) ).

fof(writeUnaryOperator_152,axiom,
    ! [VarCurr] :
      ( ~ v1843(VarCurr)
    <=> v1819(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_403,axiom,
    ! [VarCurr] :
      ( v1814(VarCurr)
    <=> ( v1815(VarCurr)
        & v1840(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_402,axiom,
    ! [VarCurr] :
      ( v1840(VarCurr)
    <=> ( v1817(VarCurr)
        | v1837(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_401,axiom,
    ! [VarCurr] :
      ( v1815(VarCurr)
    <=> ( v1816(VarCurr)
        | v1836(VarCurr) ) ) ).

fof(writeUnaryOperator_151,axiom,
    ! [VarCurr] :
      ( ~ v1836(VarCurr)
    <=> v1837(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_400,axiom,
    ! [VarCurr] :
      ( v1837(VarCurr)
    <=> ( v1838(VarCurr)
        & v1839(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_69,axiom,
    ! [VarCurr] :
      ( v1839(VarCurr)
    <=> ( v1634(VarCurr,bitIndex4)
        | v1729(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_399,axiom,
    ! [VarCurr] :
      ( v1838(VarCurr)
    <=> ( v1686(VarCurr)
        | v1769(VarCurr) ) ) ).

fof(writeUnaryOperator_150,axiom,
    ! [VarCurr] :
      ( ~ v1816(VarCurr)
    <=> v1817(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_398,axiom,
    ! [VarCurr] :
      ( v1817(VarCurr)
    <=> ( v1818(VarCurr)
        | v1835(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_68,axiom,
    ! [VarCurr] :
      ( v1835(VarCurr)
    <=> ( v1634(VarCurr,bitIndex3)
        & v1729(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_397,axiom,
    ! [VarCurr] :
      ( v1818(VarCurr)
    <=> ( v1819(VarCurr)
        & v1832(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_396,axiom,
    ! [VarCurr] :
      ( v1832(VarCurr)
    <=> ( v1833(VarCurr)
        & v1834(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_67,axiom,
    ! [VarCurr] :
      ( v1834(VarCurr)
    <=> ( v1634(VarCurr,bitIndex3)
        | v1729(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_395,axiom,
    ! [VarCurr] :
      ( v1833(VarCurr)
    <=> ( v1691(VarCurr)
        | v1774(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_394,axiom,
    ! [VarCurr] :
      ( v1819(VarCurr)
    <=> ( v1820(VarCurr)
        | v1831(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_66,axiom,
    ! [VarCurr] :
      ( v1831(VarCurr)
    <=> ( v1634(VarCurr,bitIndex2)
        & v1729(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_393,axiom,
    ! [VarCurr] :
      ( v1820(VarCurr)
    <=> ( v1821(VarCurr)
        & v1828(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_392,axiom,
    ! [VarCurr] :
      ( v1828(VarCurr)
    <=> ( v1829(VarCurr)
        & v1830(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_65,axiom,
    ! [VarCurr] :
      ( v1830(VarCurr)
    <=> ( v1634(VarCurr,bitIndex2)
        | v1729(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_391,axiom,
    ! [VarCurr] :
      ( v1829(VarCurr)
    <=> ( v1696(VarCurr)
        | v1779(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_390,axiom,
    ! [VarCurr] :
      ( v1821(VarCurr)
    <=> ( v1822(VarCurr)
        | v1827(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_64,axiom,
    ! [VarCurr] :
      ( v1827(VarCurr)
    <=> ( v1634(VarCurr,bitIndex1)
        & v1729(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_389,axiom,
    ! [VarCurr] :
      ( v1822(VarCurr)
    <=> ( v1823(VarCurr)
        & v1824(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_388,axiom,
    ! [VarCurr] :
      ( v1824(VarCurr)
    <=> ( v1825(VarCurr)
        & v1826(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_63,axiom,
    ! [VarCurr] :
      ( v1826(VarCurr)
    <=> ( v1634(VarCurr,bitIndex1)
        | v1729(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_387,axiom,
    ! [VarCurr] :
      ( v1825(VarCurr)
    <=> ( v1701(VarCurr)
        | v1784(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_386,axiom,
    ! [VarCurr] :
      ( v1823(VarCurr)
    <=> ( v1634(VarCurr,bitIndex0)
        & v1729(VarCurr,bitIndex0) ) ) ).

fof(addBitVectorEqualityBitBlasted_82,axiom,
    ! [VarCurr] :
      ( v1809(VarCurr)
    <=> ( ( v1634(VarCurr,bitIndex4)
        <=> $false )
        & ( v1634(VarCurr,bitIndex3)
        <=> $false )
        & ( v1634(VarCurr,bitIndex2)
        <=> $false )
        & ( v1634(VarCurr,bitIndex1)
        <=> $false )
        & ( v1634(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_81,axiom,
    ! [VarCurr] :
      ( v1806(VarCurr)
    <=> ( ( v1604(VarCurr,bitIndex1)
        <=> $true )
        & ( v1604(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_37,axiom,
    ! [VarCurr] :
      ( ~ v1796(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1795(VarCurr,B)
          <=> v1798(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_39,axiom,
    ! [VarCurr] :
      ( v1796(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1795(VarCurr,B)
          <=> $false ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_36,axiom,
    ! [VarCurr] :
      ( ~ v1799(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1798(VarCurr,B)
          <=> b01(B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_38,axiom,
    ! [VarCurr] :
      ( v1799(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1798(VarCurr,B)
          <=> b10(B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_385,axiom,
    ! [VarCurr] :
      ( v1799(VarCurr)
    <=> ( v1310(VarCurr)
        & v1800(VarCurr) ) ) ).

fof(writeUnaryOperator_149,axiom,
    ! [VarCurr] :
      ( ~ v1800(VarCurr)
    <=> v1802(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_384,axiom,
    ! [VarCurr] :
      ( v1802(VarCurr)
    <=> ( v1803(VarCurr)
        & v1686(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_383,axiom,
    ! [VarCurr] :
      ( v1803(VarCurr)
    <=> ( v1804(VarCurr)
        & v1691(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_382,axiom,
    ! [VarCurr] :
      ( v1804(VarCurr)
    <=> ( v1805(VarCurr)
        & v1696(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_381,axiom,
    ! [VarCurr] :
      ( v1805(VarCurr)
    <=> ( v1700(VarCurr)
        & v1701(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_380,axiom,
    ! [VarCurr] :
      ( v1796(VarCurr)
    <=> ( v1310(VarCurr)
        & v1797(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_80,axiom,
    ! [VarCurr] :
      ( v1797(VarCurr)
    <=> ( ( v1634(VarCurr,bitIndex4)
        <=> $false )
        & ( v1634(VarCurr,bitIndex3)
        <=> $false )
        & ( v1634(VarCurr,bitIndex2)
        <=> $false )
        & ( v1634(VarCurr,bitIndex1)
        <=> $false )
        & ( v1634(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_79,axiom,
    ! [VarCurr] :
      ( v1794(VarCurr)
    <=> ( ( v1604(VarCurr,bitIndex1)
        <=> $false )
        & ( v1604(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_35,axiom,
    ! [VarCurr] :
      ( ~ v1608(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1791(VarCurr,B)
          <=> v1792(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_37,axiom,
    ! [VarCurr] :
      ( v1608(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1791(VarCurr,B)
          <=> $false ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_34,axiom,
    ! [VarCurr] :
      ( ~ v1396(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1792(VarCurr,B)
          <=> v1793(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_36,axiom,
    ! [VarCurr] :
      ( v1396(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1792(VarCurr,B)
          <=> b01(B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_33,axiom,
    ! [VarCurr] :
      ( ~ v1618(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1793(VarCurr,B)
          <=> $false ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_35,axiom,
    ! [VarCurr] :
      ( v1618(VarCurr)
     => ! [B] :
          ( range_1_0(B)
         => ( v1793(VarCurr,B)
          <=> b10(B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_78,axiom,
    ! [VarCurr] :
      ( v1790(VarCurr)
    <=> ( ( v1604(VarCurr,bitIndex1)
        <=> $false )
        & ( v1604(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_13,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1742(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v1729(VarNext,B)
            <=> v1729(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_25,axiom,
    ! [VarNext] :
      ( v1742(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v1729(VarNext,B)
          <=> v1759(VarNext,B) ) ) ) ).

fof(addAssignment_385,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v1759(VarNext,B)
          <=> v1757(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_32,axiom,
    ! [VarCurr] :
      ( ~ v1754(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v1757(VarCurr,B)
          <=> v1760(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_34,axiom,
    ! [VarCurr] :
      ( v1754(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v1757(VarCurr,B)
          <=> $false ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_31,axiom,
    ! [VarCurr] :
      ( ~ v1731(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v1760(VarCurr,B)
          <=> v1761(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_33,axiom,
    ! [VarCurr] :
      ( v1731(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v1760(VarCurr,B)
          <=> $false ) ) ) ).

fof(addAssignment_384,axiom,
    ! [VarCurr] :
      ( v1761(VarCurr,bitIndex0)
    <=> v1783(VarCurr) ) ).

fof(addAssignment_383,axiom,
    ! [VarCurr] :
      ( v1761(VarCurr,bitIndex1)
    <=> v1781(VarCurr) ) ).

fof(addAssignment_382,axiom,
    ! [VarCurr] :
      ( v1761(VarCurr,bitIndex2)
    <=> v1776(VarCurr) ) ).

fof(addAssignment_381,axiom,
    ! [VarCurr] :
      ( v1761(VarCurr,bitIndex3)
    <=> v1771(VarCurr) ) ).

fof(addAssignment_380,axiom,
    ! [VarCurr] :
      ( v1761(VarCurr,bitIndex4)
    <=> v1763(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_379,axiom,
    ! [VarCurr] :
      ( v1781(VarCurr)
    <=> ( v1782(VarCurr)
        & v1785(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_62,axiom,
    ! [VarCurr] :
      ( v1785(VarCurr)
    <=> ( v1729(VarCurr,bitIndex0)
        | v1729(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_378,axiom,
    ! [VarCurr] :
      ( v1782(VarCurr)
    <=> ( v1783(VarCurr)
        | v1784(VarCurr) ) ) ).

fof(writeUnaryOperator_148,axiom,
    ! [VarCurr] :
      ( ~ v1784(VarCurr)
    <=> v1729(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_147,axiom,
    ! [VarCurr] :
      ( ~ v1783(VarCurr)
    <=> v1729(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_377,axiom,
    ! [VarCurr] :
      ( v1776(VarCurr)
    <=> ( v1777(VarCurr)
        & v1780(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_61,axiom,
    ! [VarCurr] :
      ( v1780(VarCurr)
    <=> ( v1768(VarCurr)
        | v1729(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_376,axiom,
    ! [VarCurr] :
      ( v1777(VarCurr)
    <=> ( v1778(VarCurr)
        | v1779(VarCurr) ) ) ).

fof(writeUnaryOperator_146,axiom,
    ! [VarCurr] :
      ( ~ v1779(VarCurr)
    <=> v1729(VarCurr,bitIndex2) ) ).

fof(writeUnaryOperator_145,axiom,
    ! [VarCurr] :
      ( ~ v1778(VarCurr)
    <=> v1768(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_375,axiom,
    ! [VarCurr] :
      ( v1771(VarCurr)
    <=> ( v1772(VarCurr)
        & v1775(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_60,axiom,
    ! [VarCurr] :
      ( v1775(VarCurr)
    <=> ( v1767(VarCurr)
        | v1729(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_374,axiom,
    ! [VarCurr] :
      ( v1772(VarCurr)
    <=> ( v1773(VarCurr)
        | v1774(VarCurr) ) ) ).

fof(writeUnaryOperator_144,axiom,
    ! [VarCurr] :
      ( ~ v1774(VarCurr)
    <=> v1729(VarCurr,bitIndex3) ) ).

fof(writeUnaryOperator_143,axiom,
    ! [VarCurr] :
      ( ~ v1773(VarCurr)
    <=> v1767(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_373,axiom,
    ! [VarCurr] :
      ( v1763(VarCurr)
    <=> ( v1764(VarCurr)
        & v1770(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_59,axiom,
    ! [VarCurr] :
      ( v1770(VarCurr)
    <=> ( v1766(VarCurr)
        | v1729(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_372,axiom,
    ! [VarCurr] :
      ( v1764(VarCurr)
    <=> ( v1765(VarCurr)
        | v1769(VarCurr) ) ) ).

fof(writeUnaryOperator_142,axiom,
    ! [VarCurr] :
      ( ~ v1769(VarCurr)
    <=> v1729(VarCurr,bitIndex4) ) ).

fof(writeUnaryOperator_141,axiom,
    ! [VarCurr] :
      ( ~ v1765(VarCurr)
    <=> v1766(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_58,axiom,
    ! [VarCurr] :
      ( v1766(VarCurr)
    <=> ( v1767(VarCurr)
        & v1729(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_57,axiom,
    ! [VarCurr] :
      ( v1767(VarCurr)
    <=> ( v1768(VarCurr)
        & v1729(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_56,axiom,
    ! [VarCurr] :
      ( v1768(VarCurr)
    <=> ( v1729(VarCurr,bitIndex0)
        & v1729(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_371,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1742(VarNext)
      <=> ( v1743(VarNext)
          & v1750(VarNext) ) ) ) ).

fof(addAssignment_379,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1750(VarNext)
      <=> v1748(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_370,axiom,
    ! [VarCurr] :
      ( v1748(VarCurr)
    <=> ( v1751(VarCurr)
        | v1754(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_369,axiom,
    ! [VarCurr] :
      ( v1754(VarCurr)
    <=> ( v1755(VarCurr)
        | v1756(VarCurr) ) ) ).

fof(writeUnaryOperator_140,axiom,
    ! [VarCurr] :
      ( ~ v1756(VarCurr)
    <=> v1425(VarCurr) ) ).

fof(writeUnaryOperator_139,axiom,
    ! [VarCurr] :
      ( ~ v1755(VarCurr)
    <=> v104(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_368,axiom,
    ! [VarCurr] :
      ( v1751(VarCurr)
    <=> ( v1752(VarCurr)
        | v1731(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_367,axiom,
    ! [VarCurr] :
      ( v1752(VarCurr)
    <=> ( v1608(VarCurr)
        & v1753(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_77,axiom,
    ! [VarCurr] :
      ( v1753(VarCurr)
    <=> ( ( v1604(VarCurr,bitIndex1)
        <=> $true )
        & ( v1604(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_366,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1743(VarNext)
      <=> ( v1744(VarNext)
          & v303(VarNext) ) ) ) ).

fof(writeUnaryOperator_138,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1744(VarNext)
      <=> v1408(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_365,axiom,
    ! [VarCurr] :
      ( v1731(VarCurr)
    <=> ( v1733(VarCurr)
        | v1735(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_364,axiom,
    ! [VarCurr] :
      ( v1735(VarCurr)
    <=> ( v1736(VarCurr)
        & v1739(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_76,axiom,
    ! [VarCurr] :
      ( v1739(VarCurr)
    <=> ( ( v1634(VarCurr,bitIndex4)
        <=> $false )
        & ( v1634(VarCurr,bitIndex3)
        <=> $false )
        & ( v1634(VarCurr,bitIndex2)
        <=> $false )
        & ( v1634(VarCurr,bitIndex1)
        <=> $false )
        & ( v1634(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_363,axiom,
    ! [VarCurr] :
      ( v1736(VarCurr)
    <=> ( v1737(VarCurr)
        | v1738(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_75,axiom,
    ! [VarCurr] :
      ( v1738(VarCurr)
    <=> ( ( v1604(VarCurr,bitIndex1)
        <=> $true )
        & ( v1604(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_74,axiom,
    ! [VarCurr] :
      ( v1737(VarCurr)
    <=> ( ( v1604(VarCurr,bitIndex1)
        <=> $true )
        & ( v1604(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_362,axiom,
    ! [VarCurr] :
      ( v1733(VarCurr)
    <=> ( v1734(VarCurr)
        & v1310(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_73,axiom,
    ! [VarCurr] :
      ( v1734(VarCurr)
    <=> ( ( v1604(VarCurr,bitIndex1)
        <=> $false )
        & ( v1604(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_12,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1657(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v1634(VarNext,B)
            <=> v1634(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_24,axiom,
    ! [VarNext] :
      ( v1657(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v1634(VarNext,B)
          <=> v1676(VarNext,B) ) ) ) ).

fof(addAssignment_378,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v1676(VarNext,B)
          <=> v1674(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_30,axiom,
    ! [VarCurr] :
      ( ~ v1671(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v1674(VarCurr,B)
          <=> v1677(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_32,axiom,
    ! [VarCurr] :
      ( v1671(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v1674(VarCurr,B)
          <=> $false ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_29,axiom,
    ! [VarCurr] :
      ( ~ v1669(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v1677(VarCurr,B)
          <=> v1703(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_31,axiom,
    ! [VarCurr] :
      ( v1669(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v1677(VarCurr,B)
          <=> v1678(VarCurr,B) ) ) ) ).

fof(addAssignment_377,axiom,
    ! [VarCurr] :
      ( v1703(VarCurr,bitIndex0)
    <=> v1700(VarCurr) ) ).

fof(addAssignment_376,axiom,
    ! [VarCurr] :
      ( v1703(VarCurr,bitIndex1)
    <=> v1723(VarCurr) ) ).

fof(addAssignment_375,axiom,
    ! [VarCurr] :
      ( v1703(VarCurr,bitIndex2)
    <=> v1719(VarCurr) ) ).

fof(addAssignment_374,axiom,
    ! [VarCurr] :
      ( v1703(VarCurr,bitIndex3)
    <=> v1715(VarCurr) ) ).

fof(addAssignment_373,axiom,
    ! [VarCurr] :
      ( v1703(VarCurr,bitIndex4)
    <=> v1705(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_361,axiom,
    ! [VarCurr] :
      ( v1723(VarCurr)
    <=> ( v1724(VarCurr)
        & v1725(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_360,axiom,
    ! [VarCurr] :
      ( v1725(VarCurr)
    <=> ( v1634(VarCurr,bitIndex0)
        | v1701(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_55,axiom,
    ! [VarCurr] :
      ( v1724(VarCurr)
    <=> ( v1700(VarCurr)
        | v1634(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_359,axiom,
    ! [VarCurr] :
      ( v1719(VarCurr)
    <=> ( v1720(VarCurr)
        & v1722(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_358,axiom,
    ! [VarCurr] :
      ( v1722(VarCurr)
    <=> ( v1696(VarCurr)
        | v1712(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_54,axiom,
    ! [VarCurr] :
      ( v1720(VarCurr)
    <=> ( v1634(VarCurr,bitIndex2)
        | v1721(VarCurr) ) ) ).

fof(writeUnaryOperator_137,axiom,
    ! [VarCurr] :
      ( ~ v1721(VarCurr)
    <=> v1712(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_357,axiom,
    ! [VarCurr] :
      ( v1715(VarCurr)
    <=> ( v1716(VarCurr)
        & v1718(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_356,axiom,
    ! [VarCurr] :
      ( v1718(VarCurr)
    <=> ( v1691(VarCurr)
        | v1710(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_53,axiom,
    ! [VarCurr] :
      ( v1716(VarCurr)
    <=> ( v1634(VarCurr,bitIndex3)
        | v1717(VarCurr) ) ) ).

fof(writeUnaryOperator_136,axiom,
    ! [VarCurr] :
      ( ~ v1717(VarCurr)
    <=> v1710(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_355,axiom,
    ! [VarCurr] :
      ( v1705(VarCurr)
    <=> ( v1706(VarCurr)
        & v1714(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_354,axiom,
    ! [VarCurr] :
      ( v1714(VarCurr)
    <=> ( v1686(VarCurr)
        | v1708(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_52,axiom,
    ! [VarCurr] :
      ( v1706(VarCurr)
    <=> ( v1634(VarCurr,bitIndex4)
        | v1707(VarCurr) ) ) ).

fof(writeUnaryOperator_135,axiom,
    ! [VarCurr] :
      ( ~ v1707(VarCurr)
    <=> v1708(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_51,axiom,
    ! [VarCurr] :
      ( v1708(VarCurr)
    <=> ( v1634(VarCurr,bitIndex3)
        | v1709(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_353,axiom,
    ! [VarCurr] :
      ( v1709(VarCurr)
    <=> ( v1691(VarCurr)
        & v1710(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_50,axiom,
    ! [VarCurr] :
      ( v1710(VarCurr)
    <=> ( v1634(VarCurr,bitIndex2)
        | v1711(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_352,axiom,
    ! [VarCurr] :
      ( v1711(VarCurr)
    <=> ( v1696(VarCurr)
        & v1712(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_49,axiom,
    ! [VarCurr] :
      ( v1712(VarCurr)
    <=> ( v1634(VarCurr,bitIndex1)
        | v1713(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_351,axiom,
    ! [VarCurr] :
      ( v1713(VarCurr)
    <=> ( v1634(VarCurr,bitIndex0)
        & v1701(VarCurr) ) ) ).

fof(addAssignment_372,axiom,
    ! [VarCurr] :
      ( v1678(VarCurr,bitIndex0)
    <=> v1700(VarCurr) ) ).

fof(addAssignment_371,axiom,
    ! [VarCurr] :
      ( v1678(VarCurr,bitIndex1)
    <=> v1698(VarCurr) ) ).

fof(addAssignment_370,axiom,
    ! [VarCurr] :
      ( v1678(VarCurr,bitIndex2)
    <=> v1693(VarCurr) ) ).

fof(addAssignment_369,axiom,
    ! [VarCurr] :
      ( v1678(VarCurr,bitIndex3)
    <=> v1688(VarCurr) ) ).

fof(addAssignment_368,axiom,
    ! [VarCurr] :
      ( v1678(VarCurr,bitIndex4)
    <=> v1680(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_350,axiom,
    ! [VarCurr] :
      ( v1698(VarCurr)
    <=> ( v1699(VarCurr)
        & v1702(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_48,axiom,
    ! [VarCurr] :
      ( v1702(VarCurr)
    <=> ( v1634(VarCurr,bitIndex0)
        | v1634(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_349,axiom,
    ! [VarCurr] :
      ( v1699(VarCurr)
    <=> ( v1700(VarCurr)
        | v1701(VarCurr) ) ) ).

fof(writeUnaryOperator_134,axiom,
    ! [VarCurr] :
      ( ~ v1701(VarCurr)
    <=> v1634(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_133,axiom,
    ! [VarCurr] :
      ( ~ v1700(VarCurr)
    <=> v1634(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_348,axiom,
    ! [VarCurr] :
      ( v1693(VarCurr)
    <=> ( v1694(VarCurr)
        & v1697(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_47,axiom,
    ! [VarCurr] :
      ( v1697(VarCurr)
    <=> ( v1685(VarCurr)
        | v1634(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_347,axiom,
    ! [VarCurr] :
      ( v1694(VarCurr)
    <=> ( v1695(VarCurr)
        | v1696(VarCurr) ) ) ).

fof(writeUnaryOperator_132,axiom,
    ! [VarCurr] :
      ( ~ v1696(VarCurr)
    <=> v1634(VarCurr,bitIndex2) ) ).

fof(writeUnaryOperator_131,axiom,
    ! [VarCurr] :
      ( ~ v1695(VarCurr)
    <=> v1685(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_346,axiom,
    ! [VarCurr] :
      ( v1688(VarCurr)
    <=> ( v1689(VarCurr)
        & v1692(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_46,axiom,
    ! [VarCurr] :
      ( v1692(VarCurr)
    <=> ( v1684(VarCurr)
        | v1634(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_345,axiom,
    ! [VarCurr] :
      ( v1689(VarCurr)
    <=> ( v1690(VarCurr)
        | v1691(VarCurr) ) ) ).

fof(writeUnaryOperator_130,axiom,
    ! [VarCurr] :
      ( ~ v1691(VarCurr)
    <=> v1634(VarCurr,bitIndex3) ) ).

fof(writeUnaryOperator_129,axiom,
    ! [VarCurr] :
      ( ~ v1690(VarCurr)
    <=> v1684(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_344,axiom,
    ! [VarCurr] :
      ( v1680(VarCurr)
    <=> ( v1681(VarCurr)
        & v1687(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_45,axiom,
    ! [VarCurr] :
      ( v1687(VarCurr)
    <=> ( v1683(VarCurr)
        | v1634(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_343,axiom,
    ! [VarCurr] :
      ( v1681(VarCurr)
    <=> ( v1682(VarCurr)
        | v1686(VarCurr) ) ) ).

fof(writeUnaryOperator_128,axiom,
    ! [VarCurr] :
      ( ~ v1686(VarCurr)
    <=> v1634(VarCurr,bitIndex4) ) ).

fof(writeUnaryOperator_127,axiom,
    ! [VarCurr] :
      ( ~ v1682(VarCurr)
    <=> v1683(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_44,axiom,
    ! [VarCurr] :
      ( v1683(VarCurr)
    <=> ( v1684(VarCurr)
        & v1634(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_43,axiom,
    ! [VarCurr] :
      ( v1684(VarCurr)
    <=> ( v1685(VarCurr)
        & v1634(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_42,axiom,
    ! [VarCurr] :
      ( v1685(VarCurr)
    <=> ( v1634(VarCurr,bitIndex0)
        & v1634(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_342,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1657(VarNext)
      <=> ( v1658(VarNext)
          & v1665(VarNext) ) ) ) ).

fof(addAssignment_367,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1665(VarNext)
      <=> v1663(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_341,axiom,
    ! [VarCurr] :
      ( v1663(VarCurr)
    <=> ( v1666(VarCurr)
        | v1671(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_340,axiom,
    ! [VarCurr] :
      ( v1671(VarCurr)
    <=> ( v1672(VarCurr)
        | v1673(VarCurr) ) ) ).

fof(writeUnaryOperator_126,axiom,
    ! [VarCurr] :
      ( ~ v1673(VarCurr)
    <=> v1425(VarCurr) ) ).

fof(writeUnaryOperator_125,axiom,
    ! [VarCurr] :
      ( ~ v1672(VarCurr)
    <=> v104(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_339,axiom,
    ! [VarCurr] :
      ( v1666(VarCurr)
    <=> ( v1667(VarCurr)
        | v1669(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_338,axiom,
    ! [VarCurr] :
      ( v1669(VarCurr)
    <=> ( v1618(VarCurr)
        & v1670(VarCurr) ) ) ).

fof(writeUnaryOperator_124,axiom,
    ! [VarCurr] :
      ( ~ v1670(VarCurr)
    <=> v1636(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_337,axiom,
    ! [VarCurr] :
      ( v1667(VarCurr)
    <=> ( v1668(VarCurr)
        & v1636(VarCurr) ) ) ).

fof(writeUnaryOperator_123,axiom,
    ! [VarCurr] :
      ( ~ v1668(VarCurr)
    <=> v1618(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_336,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1658(VarNext)
      <=> ( v1659(VarNext)
          & v303(VarNext) ) ) ) ).

fof(writeUnaryOperator_122,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1659(VarNext)
      <=> v1408(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_335,axiom,
    ! [VarCurr] :
      ( v1636(VarCurr)
    <=> ( v1638(VarCurr)
        & v1654(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_72,axiom,
    ! [VarCurr] :
      ( v1654(VarCurr)
    <=> ( v1646(VarCurr)
      <=> $true ) ) ).

fof(addAssignment_366,axiom,
    ! [VarCurr] :
      ( v1646(VarCurr)
    <=> v1648(VarCurr,bitIndex3) ) ).

fof(addAssignment_365,axiom,
    ! [VarCurr] :
      ( v1648(VarCurr,bitIndex3)
    <=> v1650(VarCurr,bitIndex3) ) ).

fof(addAssignment_364,axiom,
    ! [VarCurr] :
      ( v1650(VarCurr,bitIndex3)
    <=> v1652(VarCurr,bitIndex3) ) ).

fof(addAssignment_363,axiom,
    ! [VarCurr] :
      ( v1638(VarCurr)
    <=> v1640(VarCurr) ) ).

fof(addAssignment_362,axiom,
    ! [VarCurr] :
      ( v1640(VarCurr)
    <=> v1642(VarCurr) ) ).

fof(addAssignment_361,axiom,
    ! [VarCurr] :
      ( v1642(VarCurr)
    <=> v1644(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_334,axiom,
    ! [VarCurr] :
      ( v1618(VarCurr)
    <=> ( v1622(VarCurr)
        & v606(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_333,axiom,
    ! [VarCurr] :
      ( v1622(VarCurr)
    <=> ( v1623(VarCurr)
        | v1632(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_71,axiom,
    ! [VarCurr] :
      ( v1632(VarCurr)
    <=> ( ( v524(VarCurr,bitIndex3)
        <=> $true )
        & ( v524(VarCurr,bitIndex2)
        <=> $true )
        & ( v524(VarCurr,bitIndex1)
        <=> $true )
        & ( v524(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_332,axiom,
    ! [VarCurr] :
      ( v1623(VarCurr)
    <=> ( v1624(VarCurr)
        | v1631(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_70,axiom,
    ! [VarCurr] :
      ( v1631(VarCurr)
    <=> ( ( v524(VarCurr,bitIndex3)
        <=> $true )
        & ( v524(VarCurr,bitIndex2)
        <=> $true )
        & ( v524(VarCurr,bitIndex1)
        <=> $true )
        & ( v524(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_219,axiom,
    b1110(bitIndex3) ).

fof(bitBlastConstant_218,axiom,
    b1110(bitIndex2) ).

fof(bitBlastConstant_217,axiom,
    b1110(bitIndex1) ).

fof(bitBlastConstant_216,axiom,
    ~ b1110(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_331,axiom,
    ! [VarCurr] :
      ( v1624(VarCurr)
    <=> ( v1625(VarCurr)
        | v1630(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_69,axiom,
    ! [VarCurr] :
      ( v1630(VarCurr)
    <=> ( ( v524(VarCurr,bitIndex3)
        <=> $true )
        & ( v524(VarCurr,bitIndex2)
        <=> $true )
        & ( v524(VarCurr,bitIndex1)
        <=> $false )
        & ( v524(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_330,axiom,
    ! [VarCurr] :
      ( v1625(VarCurr)
    <=> ( v1626(VarCurr)
        | v1629(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_68,axiom,
    ! [VarCurr] :
      ( v1629(VarCurr)
    <=> ( ( v524(VarCurr,bitIndex3)
        <=> $true )
        & ( v524(VarCurr,bitIndex2)
        <=> $true )
        & ( v524(VarCurr,bitIndex1)
        <=> $false )
        & ( v524(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_329,axiom,
    ! [VarCurr] :
      ( v1626(VarCurr)
    <=> ( v1627(VarCurr)
        | v1628(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_67,axiom,
    ! [VarCurr] :
      ( v1628(VarCurr)
    <=> ( ( v524(VarCurr,bitIndex3)
        <=> $true )
        & ( v524(VarCurr,bitIndex2)
        <=> $false )
        & ( v524(VarCurr,bitIndex1)
        <=> $false )
        & ( v524(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_66,axiom,
    ! [VarCurr] :
      ( v1627(VarCurr)
    <=> ( ( v524(VarCurr,bitIndex3)
        <=> $true )
        & ( v524(VarCurr,bitIndex2)
        <=> $false )
        & ( v524(VarCurr,bitIndex1)
        <=> $false )
        & ( v524(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_215,axiom,
    b1000(bitIndex3) ).

fof(bitBlastConstant_214,axiom,
    ~ b1000(bitIndex2) ).

fof(bitBlastConstant_213,axiom,
    ~ b1000(bitIndex1) ).

fof(bitBlastConstant_212,axiom,
    ~ b1000(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_328,axiom,
    ! [VarCurr] :
      ( v1608(VarCurr)
    <=> ( v1610(VarCurr)
        & v606(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_327,axiom,
    ! [VarCurr] :
      ( v1610(VarCurr)
    <=> ( v1611(VarCurr)
        | v1616(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_65,axiom,
    ! [VarCurr] :
      ( v1616(VarCurr)
    <=> ( ( v524(VarCurr,bitIndex3)
        <=> $false )
        & ( v524(VarCurr,bitIndex2)
        <=> $true )
        & ( v524(VarCurr,bitIndex1)
        <=> $false )
        & ( v524(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_326,axiom,
    ! [VarCurr] :
      ( v1611(VarCurr)
    <=> ( v1612(VarCurr)
        | v1615(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_64,axiom,
    ! [VarCurr] :
      ( v1615(VarCurr)
    <=> ( ( v524(VarCurr,bitIndex3)
        <=> $false )
        & ( v524(VarCurr,bitIndex2)
        <=> $true )
        & ( v524(VarCurr,bitIndex1)
        <=> $false )
        & ( v524(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_325,axiom,
    ! [VarCurr] :
      ( v1612(VarCurr)
    <=> ( v1613(VarCurr)
        | v1614(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_63,axiom,
    ! [VarCurr] :
      ( v1614(VarCurr)
    <=> ( ( v524(VarCurr,bitIndex3)
        <=> $false )
        & ( v524(VarCurr,bitIndex2)
        <=> $false )
        & ( v524(VarCurr,bitIndex1)
        <=> $false )
        & ( v524(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_62,axiom,
    ! [VarCurr] :
      ( v1613(VarCurr)
    <=> ( ( v524(VarCurr,bitIndex3)
        <=> $false )
        & ( v524(VarCurr,bitIndex2)
        <=> $false )
        & ( v524(VarCurr,bitIndex1)
        <=> $false )
        & ( v524(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_360,axiom,
    ! [VarCurr] :
      ( v1425(VarCurr)
    <=> v1427(VarCurr) ) ).

fof(addAssignment_359,axiom,
    ! [VarCurr] :
      ( v1427(VarCurr)
    <=> v1429(VarCurr) ) ).

fof(addAssignment_358,axiom,
    ! [VarCurr] :
      ( v1429(VarCurr)
    <=> v1431(VarCurr) ) ).

fof(addAssignment_357,axiom,
    ! [VarCurr] :
      ( v1431(VarCurr)
    <=> v1433(VarCurr) ) ).

fof(addAssignment_356,axiom,
    ! [VarCurr] :
      ( v1433(VarCurr)
    <=> v1435(VarCurr,bitIndex0) ) ).

fof(addAssignment_355,axiom,
    ! [VarCurr] :
      ( v1435(VarCurr,bitIndex0)
    <=> v1437(VarCurr,bitIndex0) ) ).

fof(addAssignment_354,axiom,
    ! [VarCurr] :
      ( v1437(VarCurr,bitIndex0)
    <=> v1439(VarCurr,bitIndex0) ) ).

fof(addAssignment_353,axiom,
    ! [VarCurr] :
      ( v1439(VarCurr,bitIndex0)
    <=> v1441(VarCurr,bitIndex0) ) ).

fof(addAssignment_352,axiom,
    ! [VarCurr] :
      ( v1441(VarCurr,bitIndex0)
    <=> v1443(VarCurr,bitIndex0) ) ).

fof(addAssignment_351,axiom,
    ! [VarCurr] :
      ( v1443(VarCurr,bitIndex0)
    <=> v1445(VarCurr,bitIndex0) ) ).

fof(addAssignment_350,axiom,
    ! [VarCurr] :
      ( v1445(VarCurr,bitIndex0)
    <=> v1447(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_11,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1557(VarNext)
       => ( v1447(VarNext)
        <=> v1447(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_23,axiom,
    ! [VarNext] :
      ( v1557(VarNext)
     => ( v1447(VarNext)
      <=> v1592(VarNext) ) ) ).

fof(addAssignment_349,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1592(VarNext)
      <=> v1590(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_10,axiom,
    ! [VarCurr] :
      ( ~ v1449(VarCurr)
     => ( v1590(VarCurr)
      <=> v1593(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_10,axiom,
    ! [VarCurr] :
      ( v1449(VarCurr)
     => ( v1590(VarCurr)
      <=> v1472(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_9,axiom,
    ! [VarCurr] :
      ( ~ v1570(VarCurr)
     => ( v1593(VarCurr)
      <=> v1540(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_9,axiom,
    ! [VarCurr] :
      ( v1570(VarCurr)
     => ( v1593(VarCurr)
      <=> v1594(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_4,axiom,
    ! [VarCurr] :
      ( ( ~ v1573(VarCurr)
        & ~ v1575(VarCurr) )
     => ( v1594(VarCurr)
      <=> v1598(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_8,axiom,
    ! [VarCurr] :
      ( v1575(VarCurr)
     => ( v1594(VarCurr)
      <=> v1597(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_8,axiom,
    ! [VarCurr] :
      ( v1573(VarCurr)
     => ( v1594(VarCurr)
      <=> v1595(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_7,axiom,
    ! [VarCurr] :
      ( ~ v1583(VarCurr)
     => ( v1598(VarCurr)
      <=> v1540(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_7,axiom,
    ! [VarCurr] :
      ( v1583(VarCurr)
     => ( v1598(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_6,axiom,
    ! [VarCurr] :
      ( ~ v1577(VarCurr)
     => ( v1597(VarCurr)
      <=> v1540(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_6,axiom,
    ! [VarCurr] :
      ( v1577(VarCurr)
     => ( v1597(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_28,axiom,
    ! [VarCurr] :
      ( ~ v1596(VarCurr)
     => ( v1595(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_30,axiom,
    ! [VarCurr] :
      ( v1596(VarCurr)
     => ( v1595(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_61,axiom,
    ! [VarCurr] :
      ( v1596(VarCurr)
    <=> ( v1481(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_324,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1557(VarNext)
      <=> ( v1558(VarNext)
          & v1567(VarNext) ) ) ) ).

fof(addAssignment_348,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1567(VarNext)
      <=> v1565(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_323,axiom,
    ! [VarCurr] :
      ( v1565(VarCurr)
    <=> ( v1449(VarCurr)
        | v1568(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_322,axiom,
    ! [VarCurr] :
      ( v1568(VarCurr)
    <=> ( v1569(VarCurr)
        & v1589(VarCurr) ) ) ).

fof(writeUnaryOperator_121,axiom,
    ! [VarCurr] :
      ( ~ v1589(VarCurr)
    <=> v1449(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_321,axiom,
    ! [VarCurr] :
      ( v1569(VarCurr)
    <=> ( v1570(VarCurr)
        | v1587(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_320,axiom,
    ! [VarCurr] :
      ( v1587(VarCurr)
    <=> ( v1501(VarCurr)
        & v1588(VarCurr) ) ) ).

fof(writeUnaryOperator_120,axiom,
    ! [VarCurr] :
      ( ~ v1588(VarCurr)
    <=> v1505(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_319,axiom,
    ! [VarCurr] :
      ( v1570(VarCurr)
    <=> ( v1571(VarCurr)
        & v1505(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_318,axiom,
    ! [VarCurr] :
      ( v1571(VarCurr)
    <=> ( v1572(VarCurr)
        | v1581(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_317,axiom,
    ! [VarCurr] :
      ( v1581(VarCurr)
    <=> ( v1582(VarCurr)
        & v1586(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_60,axiom,
    ! [VarCurr] :
      ( v1586(VarCurr)
    <=> ( ( v1574(VarCurr,bitIndex2)
        <=> $false )
        & ( v1574(VarCurr,bitIndex1)
        <=> $false )
        & ( v1574(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_211,axiom,
    ~ b001(bitIndex2) ).

fof(bitBlastConstant_210,axiom,
    ~ b001(bitIndex1) ).

fof(bitBlastConstant_209,axiom,
    b001(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_316,axiom,
    ! [VarCurr] :
      ( v1582(VarCurr)
    <=> ( v1583(VarCurr)
        | v1584(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_315,axiom,
    ! [VarCurr] :
      ( v1584(VarCurr)
    <=> ( v1501(VarCurr)
        & v1585(VarCurr) ) ) ).

fof(writeUnaryOperator_119,axiom,
    ! [VarCurr] :
      ( ~ v1585(VarCurr)
    <=> v1583(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_59,axiom,
    ! [VarCurr] :
      ( v1583(VarCurr)
    <=> ( v1481(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_314,axiom,
    ! [VarCurr] :
      ( v1572(VarCurr)
    <=> ( v1573(VarCurr)
        | v1575(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_313,axiom,
    ! [VarCurr] :
      ( v1575(VarCurr)
    <=> ( v1576(VarCurr)
        & v1580(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_58,axiom,
    ! [VarCurr] :
      ( v1580(VarCurr)
    <=> ( ( v1574(VarCurr,bitIndex2)
        <=> $false )
        & ( v1574(VarCurr,bitIndex1)
        <=> $true )
        & ( v1574(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_208,axiom,
    ~ b010(bitIndex2) ).

fof(bitBlastConstant_207,axiom,
    b010(bitIndex1) ).

fof(bitBlastConstant_206,axiom,
    ~ b010(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_312,axiom,
    ! [VarCurr] :
      ( v1576(VarCurr)
    <=> ( v1577(VarCurr)
        | v1578(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_311,axiom,
    ! [VarCurr] :
      ( v1578(VarCurr)
    <=> ( v1501(VarCurr)
        & v1579(VarCurr) ) ) ).

fof(writeUnaryOperator_118,axiom,
    ! [VarCurr] :
      ( ~ v1579(VarCurr)
    <=> v1577(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_57,axiom,
    ! [VarCurr] :
      ( v1577(VarCurr)
    <=> ( v1481(VarCurr)
      <=> $true ) ) ).

fof(addBitVectorEqualityBitBlasted_56,axiom,
    ! [VarCurr] :
      ( v1573(VarCurr)
    <=> ( ( v1574(VarCurr,bitIndex2)
        <=> $true )
        & ( v1574(VarCurr,bitIndex1)
        <=> $false )
        & ( v1574(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_205,axiom,
    b100(bitIndex2) ).

fof(bitBlastConstant_204,axiom,
    ~ b100(bitIndex1) ).

fof(bitBlastConstant_203,axiom,
    ~ b100(bitIndex0) ).

fof(addAssignment_347,axiom,
    ! [VarCurr] :
      ( v1574(VarCurr,bitIndex0)
    <=> v1478(VarCurr) ) ).

fof(addAssignment_346,axiom,
    ! [VarCurr] :
      ( v1574(VarCurr,bitIndex1)
    <=> v1476(VarCurr) ) ).

fof(addAssignment_345,axiom,
    ! [VarCurr] :
      ( v1574(VarCurr,bitIndex2)
    <=> v1474(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_310,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1558(VarNext)
      <=> ( v1559(VarNext)
          & v1542(VarNext) ) ) ) ).

fof(writeUnaryOperator_117,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1559(VarNext)
      <=> v1561(VarNext) ) ) ).

fof(addAssignment_344,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1561(VarNext)
      <=> v1542(VarCurr) ) ) ).

fof(addAssignment_343,axiom,
    ! [VarCurr] :
      ( v1542(VarCurr)
    <=> v1544(VarCurr) ) ).

fof(addAssignment_342,axiom,
    ! [VarCurr] :
      ( v1544(VarCurr)
    <=> v1546(VarCurr) ) ).

fof(addAssignment_341,axiom,
    ! [VarCurr] :
      ( v1546(VarCurr)
    <=> v1548(VarCurr) ) ).

fof(addAssignment_340,axiom,
    ! [VarCurr] :
      ( v1548(VarCurr)
    <=> v1550(VarCurr) ) ).

fof(addAssignment_339,axiom,
    ! [VarCurr] :
      ( v1550(VarCurr)
    <=> v1552(VarCurr) ) ).

fof(addAssignment_338,axiom,
    ! [VarCurr] :
      ( v1552(VarCurr)
    <=> v1554(VarCurr) ) ).

fof(addAssignment_337,axiom,
    ! [VarCurr] :
      ( v1554(VarCurr)
    <=> v1(VarCurr) ) ).

fof(addAssignment_336,axiom,
    ! [VarCurr] :
      ( v1540(VarCurr)
    <=> $false ) ).

fof(addAssignment_335,axiom,
    ! [VarCurr] :
      ( v1505(VarCurr)
    <=> v1507(VarCurr) ) ).

fof(addAssignment_334,axiom,
    ! [VarCurr] :
      ( v1507(VarCurr)
    <=> v1509(VarCurr) ) ).

fof(addAssignment_333,axiom,
    ! [VarCurr] :
      ( v1509(VarCurr)
    <=> v1511(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_309,axiom,
    ! [VarCurr] :
      ( v1511(VarCurr)
    <=> ( v1513(VarCurr)
        & v1525(VarCurr) ) ) ).

fof(addAssignment_332,axiom,
    ! [VarCurr] :
      ( v1525(VarCurr)
    <=> v1527(VarCurr) ) ).

fof(addAssignment_331,axiom,
    ! [VarCurr] :
      ( v1527(VarCurr)
    <=> v1529(VarCurr) ) ).

fof(addAssignment_330,axiom,
    ! [VarCurr] :
      ( v1529(VarCurr)
    <=> v1531(VarCurr) ) ).

fof(addAssignment_329,axiom,
    ! [VarCurr] :
      ( v1531(VarCurr)
    <=> v1533(VarCurr) ) ).

fof(addAssignment_328,axiom,
    ! [VarCurr] :
      ( v1533(VarCurr)
    <=> v1535(VarCurr) ) ).

fof(addAssignment_327,axiom,
    ! [VarCurr] :
      ( v1535(VarCurr)
    <=> v1537(VarCurr) ) ).

fof(addAssignment_326,axiom,
    ! [VarCurr] :
      ( v1513(VarCurr)
    <=> v1515(VarCurr) ) ).

fof(addAssignment_325,axiom,
    ! [VarCurr] :
      ( v1515(VarCurr)
    <=> v1517(VarCurr) ) ).

fof(addAssignment_324,axiom,
    ! [VarCurr] :
      ( v1517(VarCurr)
    <=> v1519(VarCurr) ) ).

fof(addAssignment_323,axiom,
    ! [VarCurr] :
      ( v1519(VarCurr)
    <=> v1521(VarCurr) ) ).

fof(addAssignment_322,axiom,
    ! [VarCurr] :
      ( v1521(VarCurr)
    <=> v1523(VarCurr) ) ).

fof(addAssignment_321,axiom,
    ! [VarCurr] :
      ( v1501(VarCurr)
    <=> $false ) ).

fof(addAssignment_320,axiom,
    ! [VarCurr] :
      ( v1481(VarCurr)
    <=> v1483(VarCurr,bitIndex0) ) ).

fof(addAssignment_319,axiom,
    ! [VarCurr] :
      ( v1483(VarCurr,bitIndex0)
    <=> v1485(VarCurr,bitIndex0) ) ).

fof(addAssignment_318,axiom,
    ! [VarCurr] :
      ( v1485(VarCurr,bitIndex0)
    <=> v1487(VarCurr,bitIndex0) ) ).

fof(addAssignment_317,axiom,
    ! [VarCurr] :
      ( v1487(VarCurr,bitIndex0)
    <=> v1489(VarCurr,bitIndex0) ) ).

fof(addAssignment_316,axiom,
    ! [VarCurr] :
      ( v1489(VarCurr,bitIndex0)
    <=> v1491(VarCurr,bitIndex0) ) ).

fof(addAssignment_315,axiom,
    ! [VarCurr] :
      ( v1491(VarCurr,bitIndex0)
    <=> v1493(VarCurr,bitIndex0) ) ).

fof(addAssignment_314,axiom,
    ! [VarCurr] :
      ( v1493(VarCurr,bitIndex0)
    <=> v1495(VarCurr,bitIndex0) ) ).

fof(addAssignment_313,axiom,
    ! [VarCurr] :
      ( v1495(VarCurr,bitIndex0)
    <=> v1497(VarCurr,bitIndex0) ) ).

fof(addAssignment_312,axiom,
    ! [VarCurr] :
      ( v1497(VarCurr,bitIndex0)
    <=> v1499(VarCurr,bitIndex0) ) ).

fof(addAssignment_311,axiom,
    ! [VarCurr] :
      ( v1478(VarCurr)
    <=> $false ) ).

fof(addAssignment_310,axiom,
    ! [VarCurr] :
      ( v1476(VarCurr)
    <=> $false ) ).

fof(addAssignment_309,axiom,
    ! [VarCurr] :
      ( v1474(VarCurr)
    <=> $true ) ).

fof(addAssignment_308,axiom,
    ! [VarCurr] :
      ( v1472(VarCurr)
    <=> $false ) ).

fof(addAssignment_307,axiom,
    ! [VarCurr] :
      ( v1449(VarCurr)
    <=> v1451(VarCurr) ) ).

fof(writeUnaryOperator_116,axiom,
    ! [VarCurr] :
      ( ~ v1451(VarCurr)
    <=> v1453(VarCurr) ) ).

fof(addAssignment_306,axiom,
    ! [VarCurr] :
      ( v1453(VarCurr)
    <=> v1455(VarCurr) ) ).

fof(addAssignment_305,axiom,
    ! [VarCurr] :
      ( v1455(VarCurr)
    <=> v1457(VarCurr) ) ).

fof(addAssignment_304,axiom,
    ! [VarCurr] :
      ( v1457(VarCurr)
    <=> v1459(VarCurr) ) ).

fof(addAssignment_303,axiom,
    ! [VarCurr] :
      ( v1459(VarCurr)
    <=> v1461(VarCurr) ) ).

fof(addAssignment_302,axiom,
    ! [VarCurr] :
      ( v1461(VarCurr)
    <=> v1463(VarCurr) ) ).

fof(addAssignment_301,axiom,
    ! [VarCurr] :
      ( v1463(VarCurr)
    <=> v1465(VarCurr) ) ).

fof(addAssignment_300,axiom,
    ! [VarCurr] :
      ( v1465(VarCurr)
    <=> v1467(VarCurr) ) ).

fof(addAssignment_299,axiom,
    ! [VarCurr] :
      ( v1467(VarCurr)
    <=> v1469(VarCurr) ) ).

fof(addAssignment_298,axiom,
    ! [VarCurr] :
      ( v1469(VarCurr)
    <=> v14(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_10,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1404(VarNext)
       => ( v1308(VarNext)
        <=> v1308(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_22,axiom,
    ! [VarNext] :
      ( v1404(VarNext)
     => ( v1308(VarNext)
      <=> v1420(VarNext) ) ) ).

fof(addAssignment_297,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1420(VarNext)
      <=> v1418(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_27,axiom,
    ! [VarCurr] :
      ( ~ v1417(VarCurr)
     => ( v1418(VarCurr)
      <=> v1421(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_29,axiom,
    ! [VarCurr] :
      ( v1417(VarCurr)
     => ( v1418(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_26,axiom,
    ! [VarCurr] :
      ( ~ v1310(VarCurr)
     => ( v1421(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_28,axiom,
    ! [VarCurr] :
      ( v1310(VarCurr)
     => ( v1421(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_308,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1404(VarNext)
      <=> ( v1405(VarNext)
          & v1414(VarNext) ) ) ) ).

fof(addAssignment_296,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1414(VarNext)
      <=> v1412(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_307,axiom,
    ! [VarCurr] :
      ( v1412(VarCurr)
    <=> ( v1415(VarCurr)
        | v1417(VarCurr) ) ) ).

fof(writeUnaryOperator_115,axiom,
    ! [VarCurr] :
      ( ~ v1417(VarCurr)
    <=> v104(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_306,axiom,
    ! [VarCurr] :
      ( v1415(VarCurr)
    <=> ( v1416(VarCurr)
        | v1310(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_305,axiom,
    ! [VarCurr] :
      ( v1416(VarCurr)
    <=> ( v1353(VarCurr)
        & v1396(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_304,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1405(VarNext)
      <=> ( v1406(VarNext)
          & v303(VarNext) ) ) ) ).

fof(writeUnaryOperator_114,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1406(VarNext)
      <=> v1408(VarNext) ) ) ).

fof(addAssignment_295,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1408(VarNext)
      <=> v303(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_303,axiom,
    ! [VarCurr] :
      ( v1396(VarCurr)
    <=> ( v1399(VarCurr)
        & v606(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_302,axiom,
    ! [VarCurr] :
      ( v1399(VarCurr)
    <=> ( v1400(VarCurr)
        | v1401(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_55,axiom,
    ! [VarCurr] :
      ( v1401(VarCurr)
    <=> ( ( v524(VarCurr,bitIndex3)
        <=> $false )
        & ( v524(VarCurr,bitIndex2)
        <=> $true )
        & ( v524(VarCurr,bitIndex1)
        <=> $true )
        & ( v524(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_202,axiom,
    ~ b0111(bitIndex3) ).

fof(bitBlastConstant_201,axiom,
    b0111(bitIndex2) ).

fof(bitBlastConstant_200,axiom,
    b0111(bitIndex1) ).

fof(bitBlastConstant_199,axiom,
    b0111(bitIndex0) ).

fof(addBitVectorEqualityBitBlasted_54,axiom,
    ! [VarCurr] :
      ( v1400(VarCurr)
    <=> ( ( v524(VarCurr,bitIndex3)
        <=> $false )
        & ( v524(VarCurr,bitIndex2)
        <=> $true )
        & ( v524(VarCurr,bitIndex1)
        <=> $true )
        & ( v524(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_294,axiom,
    ! [VarCurr] :
      ( ( v524(VarCurr,bitIndex2)
      <=> v526(VarCurr,bitIndex65) )
      & ( v524(VarCurr,bitIndex1)
      <=> v526(VarCurr,bitIndex64) )
      & ( v524(VarCurr,bitIndex0)
      <=> v526(VarCurr,bitIndex63) ) ) ).

fof(addAssignment_293,axiom,
    ! [VarCurr,B] :
      ( range_65_63(B)
     => ( v526(VarCurr,B)
      <=> v528(VarCurr,B) ) ) ).

fof(addAssignment_292,axiom,
    ! [VarCurr,B] :
      ( range_65_63(B)
     => ( v528(VarCurr,B)
      <=> v598(VarCurr,B) ) ) ).

fof(range_axiom_12,axiom,
    ! [B] :
      ( range_65_63(B)
    <=> ( $false
        | bitIndex63 = B
        | bitIndex64 = B
        | bitIndex65 = B ) ) ).

fof(addAssignment_291,axiom,
    ! [VarCurr] :
      ( v1353(VarCurr)
    <=> v1355(VarCurr) ) ).

fof(addAssignment_290,axiom,
    ! [VarCurr] :
      ( v1355(VarCurr)
    <=> v1357(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_9,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1379(VarNext)
       => ( v1357(VarNext)
        <=> v1357(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_21,axiom,
    ! [VarNext] :
      ( v1379(VarNext)
     => ( v1357(VarNext)
      <=> v1389(VarNext) ) ) ).

fof(addAssignment_289,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1389(VarNext)
      <=> v1387(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_25,axiom,
    ! [VarCurr] :
      ( ~ v1390(VarCurr)
     => ( v1387(VarCurr)
      <=> x1372(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_27,axiom,
    ! [VarCurr] :
      ( v1390(VarCurr)
     => ( v1387(VarCurr)
      <=> v1367(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_301,axiom,
    ! [VarCurr] :
      ( v1390(VarCurr)
    <=> ( v1391(VarCurr)
        & v1392(VarCurr) ) ) ).

fof(writeUnaryOperator_113,axiom,
    ! [VarCurr] :
      ( ~ v1392(VarCurr)
    <=> v1363(VarCurr) ) ).

fof(writeUnaryOperator_112,axiom,
    ! [VarCurr] :
      ( ~ v1391(VarCurr)
    <=> v1359(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_300,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1379(VarNext)
      <=> v1380(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_299,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1380(VarNext)
      <=> ( v1381(VarNext)
          & v1374(VarNext) ) ) ) ).

fof(writeUnaryOperator_111,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1381(VarNext)
      <=> v1383(VarNext) ) ) ).

fof(addAssignment_288,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1383(VarNext)
      <=> v1374(VarCurr) ) ) ).

fof(addAssignment_287,axiom,
    ! [VarCurr] :
      ( v1374(VarCurr)
    <=> v1376(VarCurr) ) ).

fof(addAssignment_286,axiom,
    ! [VarCurr] :
      ( v1376(VarCurr)
    <=> v303(VarCurr) ) ).

fof(addAssignment_285,axiom,
    ! [VarCurr] :
      ( v1367(VarCurr)
    <=> v1369(VarCurr) ) ).

fof(addAssignment_284,axiom,
    ! [VarCurr] :
      ( v1369(VarCurr)
    <=> v1371(VarCurr) ) ).

fof(addAssignment_283,axiom,
    ! [VarCurr] :
      ( v1363(VarCurr)
    <=> v1365(VarCurr) ) ).

fof(addAssignment_282,axiom,
    ! [VarCurr] :
      ( v1365(VarCurr)
    <=> $false ) ).

fof(addAssignment_281,axiom,
    ! [VarCurr] :
      ( v1359(VarCurr)
    <=> v1361(VarCurr) ) ).

fof(addAssignment_280,axiom,
    ! [VarCurr] :
      ( v1361(VarCurr)
    <=> $false ) ).

fof(addAssignment_279,axiom,
    ! [VarCurr] :
      ( v1310(VarCurr)
    <=> v1312(VarCurr) ) ).

fof(addAssignment_278,axiom,
    ! [VarCurr] :
      ( v1312(VarCurr)
    <=> v1314(VarCurr) ) ).

fof(addAssignment_277,axiom,
    ! [VarCurr] :
      ( v1314(VarCurr)
    <=> v1316(VarCurr) ) ).

fof(addAssignment_276,axiom,
    ! [VarCurr] :
      ( v1316(VarCurr)
    <=> v1318(VarCurr) ) ).

fof(addAssignment_275,axiom,
    ! [VarCurr] :
      ( v1318(VarCurr)
    <=> v1320(VarCurr) ) ).

fof(addAssignment_274,axiom,
    ! [VarCurr] :
      ( v1320(VarCurr)
    <=> v1322(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_24,axiom,
    ! [VarCurr] :
      ( ~ v1340(VarCurr)
     => ( v1322(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_26,axiom,
    ! [VarCurr] :
      ( v1340(VarCurr)
     => ( v1322(VarCurr)
      <=> v1343(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_5,axiom,
    ! [VarCurr] :
      ( ~ v1341(VarCurr)
     => ( v1343(VarCurr)
      <=> v1348(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_5,axiom,
    ! [VarCurr] :
      ( v1341(VarCurr)
     => ( v1343(VarCurr)
      <=> v1344(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_23,axiom,
    ! [VarCurr] :
      ( ~ v1349(VarCurr)
     => ( v1348(VarCurr)
      <=> v1350(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_25,axiom,
    ! [VarCurr] :
      ( v1349(VarCurr)
     => ( v1348(VarCurr)
      <=> $true ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_22,axiom,
    ! [VarCurr] :
      ( ~ v1351(VarCurr)
     => ( v1350(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_24,axiom,
    ! [VarCurr] :
      ( v1351(VarCurr)
     => ( v1350(VarCurr)
      <=> $false ) ) ).

fof(writeUnaryOperator_110,axiom,
    ! [VarCurr] :
      ( ~ v1351(VarCurr)
    <=> v1326(VarCurr) ) ).

fof(writeUnaryOperator_109,axiom,
    ! [VarCurr] :
      ( ~ v1349(VarCurr)
    <=> v1333(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_21,axiom,
    ! [VarCurr] :
      ( ~ v1345(VarCurr)
     => ( v1344(VarCurr)
      <=> v1346(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_23,axiom,
    ! [VarCurr] :
      ( v1345(VarCurr)
     => ( v1344(VarCurr)
      <=> $false ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_20,axiom,
    ! [VarCurr] :
      ( ~ v1347(VarCurr)
     => ( v1346(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_22,axiom,
    ! [VarCurr] :
      ( v1347(VarCurr)
     => ( v1346(VarCurr)
      <=> $true ) ) ).

fof(writeUnaryOperator_108,axiom,
    ! [VarCurr] :
      ( ~ v1347(VarCurr)
    <=> v1333(VarCurr) ) ).

fof(writeUnaryOperator_107,axiom,
    ! [VarCurr] :
      ( ~ v1345(VarCurr)
    <=> v1326(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_298,axiom,
    ! [VarCurr] :
      ( v1340(VarCurr)
    <=> ( v1341(VarCurr)
        | v1342(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_53,axiom,
    ! [VarCurr] :
      ( v1342(VarCurr)
    <=> ( $true
      <=> v1324(VarCurr,bitIndex1) ) ) ).

fof(addBitVectorEqualityBitBlasted_52,axiom,
    ! [VarCurr] :
      ( v1341(VarCurr)
    <=> ( $true
      <=> v1324(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_273,axiom,
    ! [VarCurr] :
      ( v1333(VarCurr)
    <=> v1335(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_51,axiom,
    ! [VarCurr] :
      ( v1335(VarCurr)
    <=> ( ( v1337(VarCurr,bitIndex4)
        <=> $false )
        & ( v1337(VarCurr,bitIndex3)
        <=> $false )
        & ( v1337(VarCurr,bitIndex2)
        <=> $false )
        & ( v1337(VarCurr,bitIndex1)
        <=> $false )
        & ( v1337(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_272,axiom,
    ! [VarCurr] :
      ( v1326(VarCurr)
    <=> v1328(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_50,axiom,
    ! [VarCurr] :
      ( v1328(VarCurr)
    <=> ( ( v1330(VarCurr,bitIndex4)
        <=> $false )
        & ( v1330(VarCurr,bitIndex3)
        <=> $false )
        & ( v1330(VarCurr,bitIndex2)
        <=> $false )
        & ( v1330(VarCurr,bitIndex1)
        <=> $false )
        & ( v1330(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_271,axiom,
    ! [VarCurr] :
      ( v220(VarCurr)
    <=> v222(VarCurr) ) ).

fof(writeUnaryOperator_106,axiom,
    ! [VarCurr] :
      ( ~ v222(VarCurr)
    <=> v224(VarCurr) ) ).

fof(addAssignment_270,axiom,
    ! [VarCurr] :
      ( v224(VarCurr)
    <=> v226(VarCurr) ) ).

fof(addAssignment_269,axiom,
    ! [VarCurr] :
      ( v226(VarCurr)
    <=> v228(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_49,axiom,
    ! [VarCurr] :
      ( v228(VarCurr)
    <=> ( ( v230(VarCurr,bitIndex3)
        <=> $false )
        & ( v230(VarCurr,bitIndex2)
        <=> $false )
        & ( v230(VarCurr,bitIndex1)
        <=> $false )
        & ( v230(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_8,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1281(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v230(VarNext,B)
            <=> v230(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_20,axiom,
    ! [VarNext] :
      ( v1281(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v230(VarNext,B)
          <=> v1291(VarNext,B) ) ) ) ).

fof(addAssignment_268,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v1291(VarNext,B)
          <=> v1289(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_19,axiom,
    ! [VarCurr] :
      ( ~ v1292(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v1289(VarCurr,B)
          <=> v234(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_21,axiom,
    ! [VarCurr] :
      ( v1292(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v1289(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_105,axiom,
    ! [VarCurr] :
      ( ~ v1292(VarCurr)
    <=> v232(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_297,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1281(VarNext)
      <=> v1282(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_296,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1282(VarNext)
      <=> ( v1283(VarNext)
          & v1278(VarNext) ) ) ) ).

fof(writeUnaryOperator_104,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1283(VarNext)
      <=> v1285(VarNext) ) ) ).

fof(addAssignment_267,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1285(VarNext)
      <=> v1278(VarCurr) ) ) ).

fof(addAssignment_266,axiom,
    ! [VarCurr] :
      ( v1278(VarCurr)
    <=> v303(VarCurr) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_2,axiom,
    ! [VarCurr] :
      ( ( ~ v1216(VarCurr)
        & ~ v1218(VarCurr)
        & ~ v1252(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v234(VarCurr,B)
          <=> v230(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_3,axiom,
    ! [VarCurr] :
      ( v1252(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v234(VarCurr,B)
          <=> v1254(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_4,axiom,
    ! [VarCurr] :
      ( v1218(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v234(VarCurr,B)
          <=> v1220(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_4,axiom,
    ! [VarCurr] :
      ( v1216(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v234(VarCurr,B)
          <=> v230(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_48,axiom,
    ! [VarCurr] :
      ( v1275(VarCurr)
    <=> ( ( v1276(VarCurr,bitIndex1)
        <=> $true )
        & ( v1276(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_265,axiom,
    ! [VarCurr] :
      ( v1276(VarCurr,bitIndex0)
    <=> v246(VarCurr) ) ).

fof(addAssignment_264,axiom,
    ! [VarCurr] :
      ( v1276(VarCurr,bitIndex1)
    <=> v236(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_18,axiom,
    ! [VarCurr] :
      ( ~ v1255(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v1254(VarCurr,B)
          <=> v1256(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_20,axiom,
    ! [VarCurr] :
      ( v1255(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v1254(VarCurr,B)
          <=> b0110(B) ) ) ) ).

fof(addAssignment_263,axiom,
    ! [VarCurr] :
      ( v1256(VarCurr,bitIndex0)
    <=> v1272(VarCurr) ) ).

fof(addAssignment_262,axiom,
    ! [VarCurr] :
      ( v1256(VarCurr,bitIndex1)
    <=> v1270(VarCurr) ) ).

fof(addAssignment_261,axiom,
    ! [VarCurr] :
      ( v1256(VarCurr,bitIndex2)
    <=> v1265(VarCurr) ) ).

fof(addAssignment_260,axiom,
    ! [VarCurr] :
      ( v1256(VarCurr,bitIndex3)
    <=> v1258(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_295,axiom,
    ! [VarCurr] :
      ( v1270(VarCurr)
    <=> ( v1271(VarCurr)
        & v1274(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_41,axiom,
    ! [VarCurr] :
      ( v1274(VarCurr)
    <=> ( v230(VarCurr,bitIndex0)
        | v230(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_294,axiom,
    ! [VarCurr] :
      ( v1271(VarCurr)
    <=> ( v1272(VarCurr)
        | v1273(VarCurr) ) ) ).

fof(writeUnaryOperator_103,axiom,
    ! [VarCurr] :
      ( ~ v1273(VarCurr)
    <=> v230(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_102,axiom,
    ! [VarCurr] :
      ( ~ v1272(VarCurr)
    <=> v230(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_293,axiom,
    ! [VarCurr] :
      ( v1265(VarCurr)
    <=> ( v1266(VarCurr)
        & v1269(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_40,axiom,
    ! [VarCurr] :
      ( v1269(VarCurr)
    <=> ( v1262(VarCurr)
        | v230(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_292,axiom,
    ! [VarCurr] :
      ( v1266(VarCurr)
    <=> ( v1267(VarCurr)
        | v1268(VarCurr) ) ) ).

fof(writeUnaryOperator_101,axiom,
    ! [VarCurr] :
      ( ~ v1268(VarCurr)
    <=> v230(VarCurr,bitIndex2) ) ).

fof(writeUnaryOperator_100,axiom,
    ! [VarCurr] :
      ( ~ v1267(VarCurr)
    <=> v1262(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_291,axiom,
    ! [VarCurr] :
      ( v1258(VarCurr)
    <=> ( v1259(VarCurr)
        & v1264(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_39,axiom,
    ! [VarCurr] :
      ( v1264(VarCurr)
    <=> ( v1261(VarCurr)
        | v230(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_290,axiom,
    ! [VarCurr] :
      ( v1259(VarCurr)
    <=> ( v1260(VarCurr)
        | v1263(VarCurr) ) ) ).

fof(writeUnaryOperator_99,axiom,
    ! [VarCurr] :
      ( ~ v1263(VarCurr)
    <=> v230(VarCurr,bitIndex3) ) ).

fof(writeUnaryOperator_98,axiom,
    ! [VarCurr] :
      ( ~ v1260(VarCurr)
    <=> v1261(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_38,axiom,
    ! [VarCurr] :
      ( v1261(VarCurr)
    <=> ( v1262(VarCurr)
        & v230(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_37,axiom,
    ! [VarCurr] :
      ( v1262(VarCurr)
    <=> ( v230(VarCurr,bitIndex0)
        & v230(VarCurr,bitIndex1) ) ) ).

fof(addBitVectorEqualityBitBlasted_47,axiom,
    ! [VarCurr] :
      ( v1255(VarCurr)
    <=> ( ( v230(VarCurr,bitIndex3)
        <=> $false )
        & ( v230(VarCurr,bitIndex2)
        <=> $true )
        & ( v230(VarCurr,bitIndex1)
        <=> $true )
        & ( v230(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_198,axiom,
    ~ b0110(bitIndex3) ).

fof(bitBlastConstant_197,axiom,
    b0110(bitIndex2) ).

fof(bitBlastConstant_196,axiom,
    b0110(bitIndex1) ).

fof(bitBlastConstant_195,axiom,
    ~ b0110(bitIndex0) ).

fof(addBitVectorEqualityBitBlasted_46,axiom,
    ! [VarCurr] :
      ( v1252(VarCurr)
    <=> ( ( v1253(VarCurr,bitIndex1)
        <=> $true )
        & ( v1253(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_259,axiom,
    ! [VarCurr] :
      ( v1253(VarCurr,bitIndex0)
    <=> v246(VarCurr) ) ).

fof(addAssignment_258,axiom,
    ! [VarCurr] :
      ( v1253(VarCurr,bitIndex1)
    <=> v236(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_17,axiom,
    ! [VarCurr] :
      ( ~ v1221(VarCurr)
     => ! [B] :
          ( range_31_0(B)
         => ( v1220(VarCurr,B)
          <=> v1222(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_19,axiom,
    ! [VarCurr] :
      ( v1221(VarCurr)
     => ! [B] :
          ( range_31_0(B)
         => ( v1220(VarCurr,B)
          <=> $false ) ) ) ).

fof(addSignExtensionConstraint_52,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex5)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_51,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex6)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_50,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex7)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_49,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex8)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_48,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex9)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_47,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex10)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_46,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex11)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_45,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex12)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_44,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex13)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_43,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex14)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_42,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex15)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_41,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex16)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_40,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex17)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_39,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex18)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_38,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex19)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_37,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex20)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_36,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex21)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_35,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex22)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_34,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex23)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_33,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex24)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_32,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex25)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_31,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex26)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_30,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex27)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_29,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex28)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_28,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex29)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_27,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex30)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addSignExtensionConstraint_26,axiom,
    ! [VarCurr] :
      ( v1222(VarCurr,bitIndex31)
    <=> v1223(VarCurr,bitIndex4) ) ).

fof(addAssignment_257,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v1222(VarCurr,B)
      <=> v1223(VarCurr,B) ) ) ).

fof(addAssignment_256,axiom,
    ! [VarCurr] :
      ( v1223(VarCurr,bitIndex0)
    <=> v1250(VarCurr) ) ).

fof(addAssignment_255,axiom,
    ! [VarCurr] :
      ( v1223(VarCurr,bitIndex1)
    <=> v1248(VarCurr) ) ).

fof(addAssignment_254,axiom,
    ! [VarCurr] :
      ( v1223(VarCurr,bitIndex2)
    <=> v1244(VarCurr) ) ).

fof(addAssignment_253,axiom,
    ! [VarCurr] :
      ( v1223(VarCurr,bitIndex3)
    <=> v1240(VarCurr) ) ).

fof(addAssignment_252,axiom,
    ! [VarCurr] :
      ( v1223(VarCurr,bitIndex4)
    <=> v1225(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_289,axiom,
    ! [VarCurr] :
      ( v1248(VarCurr)
    <=> ( v1249(VarCurr)
        & v1251(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_288,axiom,
    ! [VarCurr] :
      ( v1251(VarCurr)
    <=> ( v1229(VarCurr,bitIndex0)
        | v1235(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_36,axiom,
    ! [VarCurr] :
      ( v1249(VarCurr)
    <=> ( v1250(VarCurr)
        | v1229(VarCurr,bitIndex1) ) ) ).

fof(writeUnaryOperator_97,axiom,
    ! [VarCurr] :
      ( ~ v1250(VarCurr)
    <=> v1229(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_287,axiom,
    ! [VarCurr] :
      ( v1244(VarCurr)
    <=> ( v1245(VarCurr)
        & v1247(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_286,axiom,
    ! [VarCurr] :
      ( v1247(VarCurr)
    <=> ( v1233(VarCurr)
        | v1236(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_35,axiom,
    ! [VarCurr] :
      ( v1245(VarCurr)
    <=> ( v1246(VarCurr)
        | v1229(VarCurr,bitIndex2) ) ) ).

fof(writeUnaryOperator_96,axiom,
    ! [VarCurr] :
      ( ~ v1246(VarCurr)
    <=> v1233(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_285,axiom,
    ! [VarCurr] :
      ( v1240(VarCurr)
    <=> ( v1241(VarCurr)
        & v1243(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_284,axiom,
    ! [VarCurr] :
      ( v1243(VarCurr)
    <=> ( v1231(VarCurr)
        | v1237(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_34,axiom,
    ! [VarCurr] :
      ( v1241(VarCurr)
    <=> ( v1242(VarCurr)
        | v1229(VarCurr,bitIndex3) ) ) ).

fof(writeUnaryOperator_95,axiom,
    ! [VarCurr] :
      ( ~ v1242(VarCurr)
    <=> v1231(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_283,axiom,
    ! [VarCurr] :
      ( v1225(VarCurr)
    <=> ( v1226(VarCurr)
        & v1238(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_282,axiom,
    ! [VarCurr] :
      ( v1238(VarCurr)
    <=> ( v1228(VarCurr)
        | v1239(VarCurr) ) ) ).

fof(writeUnaryOperator_94,axiom,
    ! [VarCurr] :
      ( ~ v1239(VarCurr)
    <=> v1229(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_33,axiom,
    ! [VarCurr] :
      ( v1226(VarCurr)
    <=> ( v1227(VarCurr)
        | v1229(VarCurr,bitIndex4) ) ) ).

fof(writeUnaryOperator_93,axiom,
    ! [VarCurr] :
      ( ~ v1227(VarCurr)
    <=> v1228(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_32,axiom,
    ! [VarCurr] :
      ( v1228(VarCurr)
    <=> ( v1229(VarCurr,bitIndex3)
        | v1230(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_281,axiom,
    ! [VarCurr] :
      ( v1230(VarCurr)
    <=> ( v1231(VarCurr)
        & v1237(VarCurr) ) ) ).

fof(writeUnaryOperator_92,axiom,
    ! [VarCurr] :
      ( ~ v1237(VarCurr)
    <=> v1229(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_31,axiom,
    ! [VarCurr] :
      ( v1231(VarCurr)
    <=> ( v1229(VarCurr,bitIndex2)
        | v1232(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_280,axiom,
    ! [VarCurr] :
      ( v1232(VarCurr)
    <=> ( v1233(VarCurr)
        & v1236(VarCurr) ) ) ).

fof(writeUnaryOperator_91,axiom,
    ! [VarCurr] :
      ( ~ v1236(VarCurr)
    <=> v1229(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges_30,axiom,
    ! [VarCurr] :
      ( v1233(VarCurr)
    <=> ( v1229(VarCurr,bitIndex1)
        | v1234(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_279,axiom,
    ! [VarCurr] :
      ( v1234(VarCurr)
    <=> ( v1229(VarCurr,bitIndex0)
        & v1235(VarCurr) ) ) ).

fof(writeUnaryOperator_90,axiom,
    ! [VarCurr] :
      ( ~ v1235(VarCurr)
    <=> v1229(VarCurr,bitIndex1) ) ).

fof(addZeroExtensionConstraint_1,axiom,
    ! [VarCurr] : ~ v1229(VarCurr,bitIndex4) ).

fof(addAssignment_251,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v1229(VarCurr,B)
      <=> v230(VarCurr,B) ) ) ).

fof(addBitVectorEqualityBitBlasted_45,axiom,
    ! [VarCurr] :
      ( v1221(VarCurr)
    <=> ( ( v230(VarCurr,bitIndex3)
        <=> $false )
        & ( v230(VarCurr,bitIndex2)
        <=> $false )
        & ( v230(VarCurr,bitIndex1)
        <=> $false )
        & ( v230(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addBitVectorEqualityBitBlasted_44,axiom,
    ! [VarCurr] :
      ( v1218(VarCurr)
    <=> ( ( v1219(VarCurr,bitIndex1)
        <=> $false )
        & ( v1219(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_250,axiom,
    ! [VarCurr] :
      ( v1219(VarCurr,bitIndex0)
    <=> v246(VarCurr) ) ).

fof(addAssignment_249,axiom,
    ! [VarCurr] :
      ( v1219(VarCurr,bitIndex1)
    <=> v236(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_43,axiom,
    ! [VarCurr] :
      ( v1216(VarCurr)
    <=> ( ( v1217(VarCurr,bitIndex1)
        <=> $false )
        & ( v1217(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_248,axiom,
    ! [VarCurr] :
      ( v1217(VarCurr,bitIndex0)
    <=> v246(VarCurr) ) ).

fof(addAssignment_247,axiom,
    ! [VarCurr] :
      ( v1217(VarCurr,bitIndex1)
    <=> v236(VarCurr) ) ).

fof(addAssignment_246,axiom,
    ! [VarCurr] :
      ( v246(VarCurr)
    <=> v248(VarCurr) ) ).

fof(addAssignment_245,axiom,
    ! [VarCurr] :
      ( v248(VarCurr)
    <=> v250(VarCurr) ) ).

fof(addAssignment_244,axiom,
    ! [VarCurr] :
      ( v250(VarCurr)
    <=> v252(VarCurr) ) ).

fof(addAssignment_243,axiom,
    ! [VarCurr] :
      ( v252(VarCurr)
    <=> v254(VarCurr,bitIndex7) ) ).

fof(addAssignment_242,axiom,
    ! [VarNext] :
      ( v254(VarNext,bitIndex7)
    <=> v1208(VarNext,bitIndex6) ) ).

fof(addCaseBooleanConditionShiftedRanges1_11,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1209(VarNext)
       => ( ( v1208(VarNext,bitIndex10)
          <=> v254(VarCurr,bitIndex11) )
          & ( v1208(VarNext,bitIndex9)
          <=> v254(VarCurr,bitIndex10) )
          & ( v1208(VarNext,bitIndex8)
          <=> v254(VarCurr,bitIndex9) )
          & ( v1208(VarNext,bitIndex7)
          <=> v254(VarCurr,bitIndex8) )
          & ( v1208(VarNext,bitIndex6)
          <=> v254(VarCurr,bitIndex7) )
          & ( v1208(VarNext,bitIndex5)
          <=> v254(VarCurr,bitIndex6) )
          & ( v1208(VarNext,bitIndex4)
          <=> v254(VarCurr,bitIndex5) )
          & ( v1208(VarNext,bitIndex3)
          <=> v254(VarCurr,bitIndex4) )
          & ( v1208(VarNext,bitIndex2)
          <=> v254(VarCurr,bitIndex3) )
          & ( v1208(VarNext,bitIndex1)
          <=> v254(VarCurr,bitIndex2) )
          & ( v1208(VarNext,bitIndex0)
          <=> v254(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_19,axiom,
    ! [VarNext] :
      ( v1209(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v1208(VarNext,B)
          <=> v791(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_278,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1209(VarNext)
      <=> v1210(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_277,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1210(VarNext)
      <=> ( v1212(VarNext)
          & v778(VarNext) ) ) ) ).

fof(writeUnaryOperator_89,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1212(VarNext)
      <=> v785(VarNext) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_12,axiom,
    ! [VarCurr] :
      ( ~ v1184(VarCurr)
     => ( v110(VarCurr,bitIndex7)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_10,axiom,
    ! [VarCurr] :
      ( v1184(VarCurr)
     => ( v110(VarCurr,bitIndex7)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_276,axiom,
    ! [VarCurr] :
      ( v1184(VarCurr)
    <=> ( v1185(VarCurr)
        | v1205(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_275,axiom,
    ! [VarCurr] :
      ( v1205(VarCurr)
    <=> ( v1206(VarCurr)
        & v861(VarCurr) ) ) ).

fof(addAssignment_241,axiom,
    ! [VarCurr] :
      ( v1206(VarCurr)
    <=> v1192(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_274,axiom,
    ! [VarCurr] :
      ( v1185(VarCurr)
    <=> ( v1186(VarCurr)
        | v1203(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_273,axiom,
    ! [VarCurr] :
      ( v1203(VarCurr)
    <=> ( v1204(VarCurr)
        & v838(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_272,axiom,
    ! [VarCurr] :
      ( v1204(VarCurr)
    <=> ( v1192(VarCurr)
        & v616(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_271,axiom,
    ! [VarCurr] :
      ( v1186(VarCurr)
    <=> ( v1187(VarCurr)
        | v1201(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_270,axiom,
    ! [VarCurr] :
      ( v1201(VarCurr)
    <=> ( v1202(VarCurr)
        & v898(VarCurr) ) ) ).

fof(addAssignment_240,axiom,
    ! [VarCurr] :
      ( v1202(VarCurr)
    <=> v1192(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_269,axiom,
    ! [VarCurr] :
      ( v1187(VarCurr)
    <=> ( v1188(VarCurr)
        | v1199(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_268,axiom,
    ! [VarCurr] :
      ( v1199(VarCurr)
    <=> ( v1200(VarCurr)
        & v816(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_267,axiom,
    ! [VarCurr] :
      ( v1200(VarCurr)
    <=> ( v1192(VarCurr)
        & v616(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_266,axiom,
    ! [VarCurr] :
      ( v1188(VarCurr)
    <=> ( v1189(VarCurr)
        | v1197(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_265,axiom,
    ! [VarCurr] :
      ( v1197(VarCurr)
    <=> ( v1198(VarCurr)
        & v893(VarCurr) ) ) ).

fof(addAssignment_239,axiom,
    ! [VarCurr] :
      ( v1198(VarCurr)
    <=> v1192(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_264,axiom,
    ! [VarCurr] :
      ( v1189(VarCurr)
    <=> ( v1190(VarCurr)
        | v1194(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_263,axiom,
    ! [VarCurr] :
      ( v1194(VarCurr)
    <=> ( v1195(VarCurr)
        & v776(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_262,axiom,
    ! [VarCurr] :
      ( v1195(VarCurr)
    <=> ( v1192(VarCurr)
        & v616(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_261,axiom,
    ! [VarCurr] :
      ( v1192(VarCurr)
    <=> ( v1193(VarCurr)
        & v885(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_260,axiom,
    ! [VarCurr] :
      ( v1190(VarCurr)
    <=> ( v1191(VarCurr)
        & v886(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_259,axiom,
    ! [VarCurr] :
      ( v1191(VarCurr)
    <=> ( v1193(VarCurr)
        & v885(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_258,axiom,
    ! [VarCurr] :
      ( v1193(VarCurr)
    <=> ( v971(VarCurr)
        & v279(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_257,axiom,
    ! [VarCurr] :
      ( v283(VarCurr)
    <=> ( v285(VarCurr)
        & v498(VarCurr) ) ) ).

fof(addAssignment_238,axiom,
    ! [VarCurr] :
      ( v285(VarCurr)
    <=> v287(VarCurr) ) ).

fof(addAssignment_237,axiom,
    ! [VarCurr] :
      ( v287(VarCurr)
    <=> v289(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_256,axiom,
    ! [VarCurr] :
      ( v289(VarCurr)
    <=> ( v1178(VarCurr)
        & v1179(VarCurr) ) ) ).

fof(writeUnaryOperator_88,axiom,
    ! [VarCurr] :
      ( ~ v1179(VarCurr)
    <=> v486(VarCurr) ) ).

fof(writeUnaryOperator_87,axiom,
    ! [VarCurr] :
      ( ~ v1178(VarCurr)
    <=> v291(VarCurr,bitIndex1) ) ).

fof(addAssignment_236,axiom,
    ! [VarCurr] :
      ( v291(VarCurr,bitIndex1)
    <=> v293(VarCurr,bitIndex1) ) ).

fof(addAssignment_235,axiom,
    ! [VarCurr] :
      ( v293(VarCurr,bitIndex1)
    <=> v295(VarCurr,bitIndex17) ) ).

fof(addAssignment_234,axiom,
    ! [VarCurr] :
      ( v295(VarCurr,bitIndex17)
    <=> v297(VarCurr,bitIndex17) ) ).

fof(addAssignment_233,axiom,
    ! [VarCurr] :
      ( v297(VarCurr,bitIndex17)
    <=> v359(VarCurr,bitIndex17) ) ).

fof(addCaseBooleanConditionEqualRanges1_7,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1165(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v361(VarNext,B)
            <=> v361(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_18,axiom,
    ! [VarNext] :
      ( v1165(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v361(VarNext,B)
          <=> v1173(VarNext,B) ) ) ) ).

fof(addAssignment_232,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v1173(VarNext,B)
          <=> v1171(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_16,axiom,
    ! [VarCurr] :
      ( ~ v1174(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v1171(VarCurr,B)
          <=> v363(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_18,axiom,
    ! [VarCurr] :
      ( v1174(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v1171(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_86,axiom,
    ! [VarCurr] :
      ( ~ v1174(VarCurr)
    <=> v308(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_255,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1165(VarNext)
      <=> v1166(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_254,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1166(VarNext)
      <=> ( v1167(VarNext)
          & v301(VarNext) ) ) ) ).

fof(writeUnaryOperator_85,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1167(VarNext)
      <=> v341(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_15,axiom,
    ! [VarCurr] :
      ( ~ v365(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v363(VarCurr,B)
          <=> v361(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_17,axiom,
    ! [VarCurr] :
      ( v365(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v363(VarCurr,B)
          <=> v1142(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_14,axiom,
    ! [VarCurr] :
      ( ~ v1143(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v1142(VarCurr,B)
          <=> v1144(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_16,axiom,
    ! [VarCurr] :
      ( v1143(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v1142(VarCurr,B)
          <=> $false ) ) ) ).

fof(addAssignment_231,axiom,
    ! [VarCurr] :
      ( v1144(VarCurr,bitIndex0)
    <=> v1160(VarCurr) ) ).

fof(addAssignment_230,axiom,
    ! [VarCurr] :
      ( v1144(VarCurr,bitIndex1)
    <=> v1158(VarCurr) ) ).

fof(addAssignment_229,axiom,
    ! [VarCurr] :
      ( v1144(VarCurr,bitIndex2)
    <=> v1153(VarCurr) ) ).

fof(addAssignment_228,axiom,
    ! [VarCurr] :
      ( v1144(VarCurr,bitIndex3)
    <=> v1146(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_253,axiom,
    ! [VarCurr] :
      ( v1158(VarCurr)
    <=> ( v1159(VarCurr)
        & v1162(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_29,axiom,
    ! [VarCurr] :
      ( v1162(VarCurr)
    <=> ( v361(VarCurr,bitIndex0)
        | v361(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_252,axiom,
    ! [VarCurr] :
      ( v1159(VarCurr)
    <=> ( v1160(VarCurr)
        | v1161(VarCurr) ) ) ).

fof(writeUnaryOperator_84,axiom,
    ! [VarCurr] :
      ( ~ v1161(VarCurr)
    <=> v361(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_83,axiom,
    ! [VarCurr] :
      ( ~ v1160(VarCurr)
    <=> v361(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_251,axiom,
    ! [VarCurr] :
      ( v1153(VarCurr)
    <=> ( v1154(VarCurr)
        & v1157(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_28,axiom,
    ! [VarCurr] :
      ( v1157(VarCurr)
    <=> ( v1150(VarCurr)
        | v361(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_250,axiom,
    ! [VarCurr] :
      ( v1154(VarCurr)
    <=> ( v1155(VarCurr)
        | v1156(VarCurr) ) ) ).

fof(writeUnaryOperator_82,axiom,
    ! [VarCurr] :
      ( ~ v1156(VarCurr)
    <=> v361(VarCurr,bitIndex2) ) ).

fof(writeUnaryOperator_81,axiom,
    ! [VarCurr] :
      ( ~ v1155(VarCurr)
    <=> v1150(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_249,axiom,
    ! [VarCurr] :
      ( v1146(VarCurr)
    <=> ( v1147(VarCurr)
        & v1152(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_27,axiom,
    ! [VarCurr] :
      ( v1152(VarCurr)
    <=> ( v1149(VarCurr)
        | v361(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_248,axiom,
    ! [VarCurr] :
      ( v1147(VarCurr)
    <=> ( v1148(VarCurr)
        | v1151(VarCurr) ) ) ).

fof(writeUnaryOperator_80,axiom,
    ! [VarCurr] :
      ( ~ v1151(VarCurr)
    <=> v361(VarCurr,bitIndex3) ) ).

fof(writeUnaryOperator_79,axiom,
    ! [VarCurr] :
      ( ~ v1148(VarCurr)
    <=> v1149(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_26,axiom,
    ! [VarCurr] :
      ( v1149(VarCurr)
    <=> ( v1150(VarCurr)
        & v361(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_25,axiom,
    ! [VarCurr] :
      ( v1150(VarCurr)
    <=> ( v361(VarCurr,bitIndex0)
        & v361(VarCurr,bitIndex1) ) ) ).

fof(addBitVectorEqualityBitBlasted_42,axiom,
    ! [VarCurr] :
      ( v1143(VarCurr)
    <=> ( ( v361(VarCurr,bitIndex3)
        <=> $true )
        & ( v361(VarCurr,bitIndex2)
        <=> $true )
        & ( v361(VarCurr,bitIndex1)
        <=> $true )
        & ( v361(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_227,axiom,
    ! [VarCurr] :
      ( v365(VarCurr)
    <=> v367(VarCurr) ) ).

fof(addAssignment_226,axiom,
    ! [VarCurr] :
      ( v367(VarCurr)
    <=> v369(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_247,axiom,
    ! [VarCurr] :
      ( v369(VarCurr)
    <=> ( v1139(VarCurr)
        | v508(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_246,axiom,
    ! [VarCurr] :
      ( v1139(VarCurr)
    <=> ( v1140(VarCurr)
        | v108(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_245,axiom,
    ! [VarCurr] :
      ( v1140(VarCurr)
    <=> ( v371(VarCurr)
        | v496(VarCurr) ) ) ).

fof(addAssignment_225,axiom,
    ! [VarCurr] :
      ( v508(VarCurr)
    <=> v254(VarCurr,bitIndex1) ) ).

fof(addAssignment_224,axiom,
    ! [VarNext] :
      ( v254(VarNext,bitIndex1)
    <=> v1131(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionShiftedRanges1_10,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1132(VarNext)
       => ( ( v1131(VarNext,bitIndex10)
          <=> v254(VarCurr,bitIndex11) )
          & ( v1131(VarNext,bitIndex9)
          <=> v254(VarCurr,bitIndex10) )
          & ( v1131(VarNext,bitIndex8)
          <=> v254(VarCurr,bitIndex9) )
          & ( v1131(VarNext,bitIndex7)
          <=> v254(VarCurr,bitIndex8) )
          & ( v1131(VarNext,bitIndex6)
          <=> v254(VarCurr,bitIndex7) )
          & ( v1131(VarNext,bitIndex5)
          <=> v254(VarCurr,bitIndex6) )
          & ( v1131(VarNext,bitIndex4)
          <=> v254(VarCurr,bitIndex5) )
          & ( v1131(VarNext,bitIndex3)
          <=> v254(VarCurr,bitIndex4) )
          & ( v1131(VarNext,bitIndex2)
          <=> v254(VarCurr,bitIndex3) )
          & ( v1131(VarNext,bitIndex1)
          <=> v254(VarCurr,bitIndex2) )
          & ( v1131(VarNext,bitIndex0)
          <=> v254(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_17,axiom,
    ! [VarNext] :
      ( v1132(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v1131(VarNext,B)
          <=> v791(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_244,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1132(VarNext)
      <=> v1133(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_243,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1133(VarNext)
      <=> ( v1135(VarNext)
          & v778(VarNext) ) ) ) ).

fof(writeUnaryOperator_78,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1135(VarNext)
      <=> v785(VarNext) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_11,axiom,
    ! [VarCurr] :
      ( ~ v1108(VarCurr)
     => ( v110(VarCurr,bitIndex1)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_9,axiom,
    ! [VarCurr] :
      ( v1108(VarCurr)
     => ( v110(VarCurr,bitIndex1)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_242,axiom,
    ! [VarCurr] :
      ( v1108(VarCurr)
    <=> ( v1109(VarCurr)
        | v1128(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_241,axiom,
    ! [VarCurr] :
      ( v1128(VarCurr)
    <=> ( v1129(VarCurr)
        & v861(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_240,axiom,
    ! [VarCurr] :
      ( v1129(VarCurr)
    <=> ( v975(VarCurr)
        & v283(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_239,axiom,
    ! [VarCurr] :
      ( v1109(VarCurr)
    <=> ( v1110(VarCurr)
        | v1126(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_238,axiom,
    ! [VarCurr] :
      ( v1126(VarCurr)
    <=> ( v1127(VarCurr)
        & v838(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_237,axiom,
    ! [VarCurr] :
      ( v1127(VarCurr)
    <=> ( v987(VarCurr)
        & v283(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_236,axiom,
    ! [VarCurr] :
      ( v1110(VarCurr)
    <=> ( v1111(VarCurr)
        | v1124(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_235,axiom,
    ! [VarCurr] :
      ( v1124(VarCurr)
    <=> ( v1125(VarCurr)
        & v898(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_234,axiom,
    ! [VarCurr] :
      ( v1125(VarCurr)
    <=> ( v975(VarCurr)
        & v283(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_233,axiom,
    ! [VarCurr] :
      ( v1111(VarCurr)
    <=> ( v1112(VarCurr)
        | v1122(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_232,axiom,
    ! [VarCurr] :
      ( v1122(VarCurr)
    <=> ( v1123(VarCurr)
        & v816(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_231,axiom,
    ! [VarCurr] :
      ( v1123(VarCurr)
    <=> ( v987(VarCurr)
        & v283(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_230,axiom,
    ! [VarCurr] :
      ( v1112(VarCurr)
    <=> ( v1113(VarCurr)
        | v1120(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_229,axiom,
    ! [VarCurr] :
      ( v1120(VarCurr)
    <=> ( v1121(VarCurr)
        & v893(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_228,axiom,
    ! [VarCurr] :
      ( v1121(VarCurr)
    <=> ( v975(VarCurr)
        & v283(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_227,axiom,
    ! [VarCurr] :
      ( v1113(VarCurr)
    <=> ( v1114(VarCurr)
        | v1117(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_226,axiom,
    ! [VarCurr] :
      ( v1117(VarCurr)
    <=> ( v1118(VarCurr)
        & v776(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_225,axiom,
    ! [VarCurr] :
      ( v1118(VarCurr)
    <=> ( v987(VarCurr)
        & v283(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_224,axiom,
    ! [VarCurr] :
      ( v1114(VarCurr)
    <=> ( v1115(VarCurr)
        & v886(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_223,axiom,
    ! [VarCurr] :
      ( v1115(VarCurr)
    <=> ( v975(VarCurr)
        & v283(VarCurr) ) ) ).

fof(addAssignment_223,axiom,
    ! [VarCurr] :
      ( v516(VarCurr)
    <=> v518(VarCurr) ) ).

fof(addAssignment_222,axiom,
    ! [VarCurr] :
      ( v518(VarCurr)
    <=> v520(VarCurr) ) ).

fof(addAssignment_221,axiom,
    ! [VarCurr] :
      ( v520(VarCurr)
    <=> v522(VarCurr,bitIndex3) ) ).

fof(addAssignment_220,axiom,
    ! [VarCurr] :
      ( v522(VarCurr,bitIndex3)
    <=> v524(VarCurr,bitIndex3) ) ).

fof(addAssignment_219,axiom,
    ! [VarCurr] :
      ( v524(VarCurr,bitIndex3)
    <=> v526(VarCurr,bitIndex66) ) ).

fof(addAssignment_218,axiom,
    ! [VarCurr] :
      ( v526(VarCurr,bitIndex66)
    <=> v528(VarCurr,bitIndex66) ) ).

fof(addAssignment_217,axiom,
    ! [VarCurr] :
      ( v528(VarCurr,bitIndex66)
    <=> v598(VarCurr,bitIndex66) ) ).

fof(addCaseBooleanConditionEqualRanges1_6,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1093(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v600(VarNext,B)
            <=> v600(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_16,axiom,
    ! [VarNext] :
      ( v1093(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v600(VarNext,B)
          <=> v1101(VarNext,B) ) ) ) ).

fof(addAssignment_216,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v1101(VarNext,B)
          <=> v1099(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_13,axiom,
    ! [VarCurr] :
      ( ~ v1102(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v1099(VarCurr,B)
          <=> v602(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_15,axiom,
    ! [VarCurr] :
      ( v1102(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v1099(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_77,axiom,
    ! [VarCurr] :
      ( ~ v1102(VarCurr)
    <=> v535(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_222,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1093(VarNext)
      <=> v1094(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_221,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1094(VarNext)
      <=> ( v1095(VarNext)
          & v532(VarNext) ) ) ) ).

fof(writeUnaryOperator_76,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1095(VarNext)
      <=> v580(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_12,axiom,
    ! [VarCurr] :
      ( ~ v604(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v602(VarCurr,B)
          <=> v600(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_14,axiom,
    ! [VarCurr] :
      ( v604(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v602(VarCurr,B)
          <=> v1070(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_11,axiom,
    ! [VarCurr] :
      ( ~ v1071(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v1070(VarCurr,B)
          <=> v1072(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_13,axiom,
    ! [VarCurr] :
      ( v1071(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v1070(VarCurr,B)
          <=> $false ) ) ) ).

fof(addAssignment_215,axiom,
    ! [VarCurr] :
      ( v1072(VarCurr,bitIndex0)
    <=> v1088(VarCurr) ) ).

fof(addAssignment_214,axiom,
    ! [VarCurr] :
      ( v1072(VarCurr,bitIndex1)
    <=> v1086(VarCurr) ) ).

fof(addAssignment_213,axiom,
    ! [VarCurr] :
      ( v1072(VarCurr,bitIndex2)
    <=> v1081(VarCurr) ) ).

fof(addAssignment_212,axiom,
    ! [VarCurr] :
      ( v1072(VarCurr,bitIndex3)
    <=> v1074(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_220,axiom,
    ! [VarCurr] :
      ( v1086(VarCurr)
    <=> ( v1087(VarCurr)
        & v1090(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_24,axiom,
    ! [VarCurr] :
      ( v1090(VarCurr)
    <=> ( v600(VarCurr,bitIndex0)
        | v600(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_219,axiom,
    ! [VarCurr] :
      ( v1087(VarCurr)
    <=> ( v1088(VarCurr)
        | v1089(VarCurr) ) ) ).

fof(writeUnaryOperator_75,axiom,
    ! [VarCurr] :
      ( ~ v1089(VarCurr)
    <=> v600(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_74,axiom,
    ! [VarCurr] :
      ( ~ v1088(VarCurr)
    <=> v600(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_218,axiom,
    ! [VarCurr] :
      ( v1081(VarCurr)
    <=> ( v1082(VarCurr)
        & v1085(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_23,axiom,
    ! [VarCurr] :
      ( v1085(VarCurr)
    <=> ( v1078(VarCurr)
        | v600(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_217,axiom,
    ! [VarCurr] :
      ( v1082(VarCurr)
    <=> ( v1083(VarCurr)
        | v1084(VarCurr) ) ) ).

fof(writeUnaryOperator_73,axiom,
    ! [VarCurr] :
      ( ~ v1084(VarCurr)
    <=> v600(VarCurr,bitIndex2) ) ).

fof(writeUnaryOperator_72,axiom,
    ! [VarCurr] :
      ( ~ v1083(VarCurr)
    <=> v1078(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_216,axiom,
    ! [VarCurr] :
      ( v1074(VarCurr)
    <=> ( v1075(VarCurr)
        & v1080(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_22,axiom,
    ! [VarCurr] :
      ( v1080(VarCurr)
    <=> ( v1077(VarCurr)
        | v600(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_215,axiom,
    ! [VarCurr] :
      ( v1075(VarCurr)
    <=> ( v1076(VarCurr)
        | v1079(VarCurr) ) ) ).

fof(writeUnaryOperator_71,axiom,
    ! [VarCurr] :
      ( ~ v1079(VarCurr)
    <=> v600(VarCurr,bitIndex3) ) ).

fof(writeUnaryOperator_70,axiom,
    ! [VarCurr] :
      ( ~ v1076(VarCurr)
    <=> v1077(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_21,axiom,
    ! [VarCurr] :
      ( v1077(VarCurr)
    <=> ( v1078(VarCurr)
        & v600(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_20,axiom,
    ! [VarCurr] :
      ( v1078(VarCurr)
    <=> ( v600(VarCurr,bitIndex0)
        & v600(VarCurr,bitIndex1) ) ) ).

fof(addBitVectorEqualityBitBlasted_41,axiom,
    ! [VarCurr] :
      ( v1071(VarCurr)
    <=> ( ( v600(VarCurr,bitIndex3)
        <=> $true )
        & ( v600(VarCurr,bitIndex2)
        <=> $true )
        & ( v600(VarCurr,bitIndex1)
        <=> $true )
        & ( v600(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_194,axiom,
    b1111(bitIndex3) ).

fof(bitBlastConstant_193,axiom,
    b1111(bitIndex2) ).

fof(bitBlastConstant_192,axiom,
    b1111(bitIndex1) ).

fof(bitBlastConstant_191,axiom,
    b1111(bitIndex0) ).

fof(addAssignment_211,axiom,
    ! [VarCurr] :
      ( v604(VarCurr)
    <=> v606(VarCurr) ) ).

fof(addAssignment_210,axiom,
    ! [VarCurr] :
      ( v606(VarCurr)
    <=> v608(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_214,axiom,
    ! [VarCurr] :
      ( v608(VarCurr)
    <=> ( v610(VarCurr)
        | v1066(VarCurr) ) ) ).

fof(addAssignment_209,axiom,
    ! [VarCurr] :
      ( v1066(VarCurr)
    <=> v254(VarCurr,bitIndex4) ) ).

fof(addAssignment_208,axiom,
    ! [VarCurr] :
      ( v610(VarCurr)
    <=> v110(VarCurr,bitIndex6) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_10,axiom,
    ! [VarCurr] :
      ( ~ v1054(VarCurr)
     => ( v110(VarCurr,bitIndex6)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_8,axiom,
    ! [VarCurr] :
      ( v1054(VarCurr)
     => ( v110(VarCurr,bitIndex6)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_213,axiom,
    ! [VarCurr] :
      ( v1054(VarCurr)
    <=> ( v1055(VarCurr)
        | v1063(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_212,axiom,
    ! [VarCurr] :
      ( v1063(VarCurr)
    <=> ( v1064(VarCurr)
        & v1044(VarCurr) ) ) ).

fof(writeUnaryOperator_69,axiom,
    ! [VarCurr] :
      ( ~ v1064(VarCurr)
    <=> v112(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_211,axiom,
    ! [VarCurr] :
      ( v1055(VarCurr)
    <=> ( v1056(VarCurr)
        | v1061(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_210,axiom,
    ! [VarCurr] :
      ( v1061(VarCurr)
    <=> ( v1062(VarCurr)
        & v898(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_209,axiom,
    ! [VarCurr] :
      ( v1062(VarCurr)
    <=> ( v880(VarCurr)
        & v1035(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_208,axiom,
    ! [VarCurr] :
      ( v1056(VarCurr)
    <=> ( v1057(VarCurr)
        | v1059(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_207,axiom,
    ! [VarCurr] :
      ( v1059(VarCurr)
    <=> ( v1060(VarCurr)
        & v893(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_206,axiom,
    ! [VarCurr] :
      ( v1060(VarCurr)
    <=> ( v880(VarCurr)
        & v1035(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_205,axiom,
    ! [VarCurr] :
      ( v1057(VarCurr)
    <=> ( v1058(VarCurr)
        & v886(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_204,axiom,
    ! [VarCurr] :
      ( v1058(VarCurr)
    <=> ( v880(VarCurr)
        & v1035(VarCurr) ) ) ).

fof(addAssignment_207,axiom,
    ! [VarNext] :
      ( v254(VarNext,bitIndex11)
    <=> v1046(VarNext,bitIndex10) ) ).

fof(addCaseBooleanConditionShiftedRanges1_9,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1047(VarNext)
       => ( ( v1046(VarNext,bitIndex10)
          <=> v254(VarCurr,bitIndex11) )
          & ( v1046(VarNext,bitIndex9)
          <=> v254(VarCurr,bitIndex10) )
          & ( v1046(VarNext,bitIndex8)
          <=> v254(VarCurr,bitIndex9) )
          & ( v1046(VarNext,bitIndex7)
          <=> v254(VarCurr,bitIndex8) )
          & ( v1046(VarNext,bitIndex6)
          <=> v254(VarCurr,bitIndex7) )
          & ( v1046(VarNext,bitIndex5)
          <=> v254(VarCurr,bitIndex6) )
          & ( v1046(VarNext,bitIndex4)
          <=> v254(VarCurr,bitIndex5) )
          & ( v1046(VarNext,bitIndex3)
          <=> v254(VarCurr,bitIndex4) )
          & ( v1046(VarNext,bitIndex2)
          <=> v254(VarCurr,bitIndex3) )
          & ( v1046(VarNext,bitIndex1)
          <=> v254(VarCurr,bitIndex2) )
          & ( v1046(VarNext,bitIndex0)
          <=> v254(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_15,axiom,
    ! [VarNext] :
      ( v1047(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v1046(VarNext,B)
          <=> v791(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_203,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1047(VarNext)
      <=> v1048(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_202,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1048(VarNext)
      <=> ( v1050(VarNext)
          & v778(VarNext) ) ) ) ).

fof(writeUnaryOperator_68,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1050(VarNext)
      <=> v785(VarNext) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_9,axiom,
    ! [VarCurr] :
      ( ~ v1028(VarCurr)
     => ( v110(VarCurr,bitIndex11)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_7,axiom,
    ! [VarCurr] :
      ( v1028(VarCurr)
     => ( v110(VarCurr,bitIndex11)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_201,axiom,
    ! [VarCurr] :
      ( v1028(VarCurr)
    <=> ( v1029(VarCurr)
        | v1043(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_200,axiom,
    ! [VarCurr] :
      ( v1043(VarCurr)
    <=> ( v112(VarCurr)
        & v1044(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_40,axiom,
    ! [VarCurr] :
      ( v1044(VarCurr)
    <=> ( $true
      <=> v254(VarCurr,bitIndex11) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_199,axiom,
    ! [VarCurr] :
      ( v1029(VarCurr)
    <=> ( v1030(VarCurr)
        | v1040(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_198,axiom,
    ! [VarCurr] :
      ( v1040(VarCurr)
    <=> ( v1041(VarCurr)
        & v861(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_197,axiom,
    ! [VarCurr] :
      ( v1041(VarCurr)
    <=> ( v880(VarCurr)
        & v1035(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_196,axiom,
    ! [VarCurr] :
      ( v1030(VarCurr)
    <=> ( v1031(VarCurr)
        | v1038(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_195,axiom,
    ! [VarCurr] :
      ( v1038(VarCurr)
    <=> ( v1039(VarCurr)
        & v838(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_194,axiom,
    ! [VarCurr] :
      ( v1039(VarCurr)
    <=> ( v890(VarCurr)
        & v1035(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_193,axiom,
    ! [VarCurr] :
      ( v1031(VarCurr)
    <=> ( v1032(VarCurr)
        | v1036(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_192,axiom,
    ! [VarCurr] :
      ( v1036(VarCurr)
    <=> ( v1037(VarCurr)
        & v816(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_191,axiom,
    ! [VarCurr] :
      ( v1037(VarCurr)
    <=> ( v890(VarCurr)
        & v1035(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_190,axiom,
    ! [VarCurr] :
      ( v1032(VarCurr)
    <=> ( v1033(VarCurr)
        & v776(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_189,axiom,
    ! [VarCurr] :
      ( v1033(VarCurr)
    <=> ( v890(VarCurr)
        & v1035(VarCurr) ) ) ).

fof(writeUnaryOperator_67,axiom,
    ! [VarCurr] :
      ( ~ v1035(VarCurr)
    <=> v516(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_5,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1015(VarNext)
       => ( v254(VarNext,bitIndex0)
        <=> v254(VarCurr,bitIndex0) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_14,axiom,
    ! [VarNext] :
      ( v1015(VarNext)
     => ( v254(VarNext,bitIndex0)
      <=> v1023(VarNext) ) ) ).

fof(addAssignment_206,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1023(VarNext)
      <=> v1021(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_10,axiom,
    ! [VarCurr] :
      ( ~ v792(VarCurr)
     => ( v1021(VarCurr)
      <=> v110(VarCurr,bitIndex0) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_12,axiom,
    ! [VarCurr] :
      ( v792(VarCurr)
     => ( v1021(VarCurr)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_188,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1015(VarNext)
      <=> v1016(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_187,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v1016(VarNext)
      <=> ( v1018(VarNext)
          & v778(VarNext) ) ) ) ).

fof(writeUnaryOperator_66,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v1018(VarNext)
      <=> v785(VarNext) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_9,axiom,
    ! [VarCurr] :
      ( ~ v958(VarCurr)
     => ( v110(VarCurr,bitIndex0)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_11,axiom,
    ! [VarCurr] :
      ( v958(VarCurr)
     => ( v110(VarCurr,bitIndex0)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_186,axiom,
    ! [VarCurr] :
      ( v958(VarCurr)
    <=> ( v959(VarCurr)
        | v1009(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_185,axiom,
    ! [VarCurr] :
      ( v1009(VarCurr)
    <=> ( v1010(VarCurr)
        & v861(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_184,axiom,
    ! [VarCurr] :
      ( v1010(VarCurr)
    <=> ( v1011(VarCurr)
        | v1012(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_183,axiom,
    ! [VarCurr] :
      ( v1012(VarCurr)
    <=> ( v975(VarCurr)
        & v980(VarCurr) ) ) ).

fof(addAssignment_205,axiom,
    ! [VarCurr] :
      ( v1011(VarCurr)
    <=> v969(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_182,axiom,
    ! [VarCurr] :
      ( v959(VarCurr)
    <=> ( v960(VarCurr)
        | v1005(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_181,axiom,
    ! [VarCurr] :
      ( v1005(VarCurr)
    <=> ( v1006(VarCurr)
        & v838(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_180,axiom,
    ! [VarCurr] :
      ( v1006(VarCurr)
    <=> ( v1007(VarCurr)
        | v1008(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_179,axiom,
    ! [VarCurr] :
      ( v1008(VarCurr)
    <=> ( v987(VarCurr)
        & v980(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_178,axiom,
    ! [VarCurr] :
      ( v1007(VarCurr)
    <=> ( v969(VarCurr)
        & v616(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_177,axiom,
    ! [VarCurr] :
      ( v960(VarCurr)
    <=> ( v961(VarCurr)
        | v999(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_176,axiom,
    ! [VarCurr] :
      ( v999(VarCurr)
    <=> ( v1000(VarCurr)
        & v898(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_175,axiom,
    ! [VarCurr] :
      ( v1000(VarCurr)
    <=> ( v1001(VarCurr)
        | v1004(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_174,axiom,
    ! [VarCurr] :
      ( v1004(VarCurr)
    <=> ( v975(VarCurr)
        & v980(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_173,axiom,
    ! [VarCurr] :
      ( v1001(VarCurr)
    <=> ( v1002(VarCurr)
        | v1003(VarCurr) ) ) ).

fof(addAssignment_204,axiom,
    ! [VarCurr] :
      ( v1003(VarCurr)
    <=> v969(VarCurr) ) ).

fof(addAssignment_203,axiom,
    ! [VarCurr] :
      ( v1002(VarCurr)
    <=> v112(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_172,axiom,
    ! [VarCurr] :
      ( v961(VarCurr)
    <=> ( v962(VarCurr)
        | v995(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_171,axiom,
    ! [VarCurr] :
      ( v995(VarCurr)
    <=> ( v996(VarCurr)
        & v816(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_170,axiom,
    ! [VarCurr] :
      ( v996(VarCurr)
    <=> ( v997(VarCurr)
        | v998(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_169,axiom,
    ! [VarCurr] :
      ( v998(VarCurr)
    <=> ( v987(VarCurr)
        & v980(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_168,axiom,
    ! [VarCurr] :
      ( v997(VarCurr)
    <=> ( v969(VarCurr)
        & v616(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_167,axiom,
    ! [VarCurr] :
      ( v962(VarCurr)
    <=> ( v963(VarCurr)
        | v989(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_166,axiom,
    ! [VarCurr] :
      ( v989(VarCurr)
    <=> ( v990(VarCurr)
        & v893(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_165,axiom,
    ! [VarCurr] :
      ( v990(VarCurr)
    <=> ( v991(VarCurr)
        | v994(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_164,axiom,
    ! [VarCurr] :
      ( v994(VarCurr)
    <=> ( v975(VarCurr)
        & v980(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_163,axiom,
    ! [VarCurr] :
      ( v991(VarCurr)
    <=> ( v992(VarCurr)
        | v993(VarCurr) ) ) ).

fof(addAssignment_202,axiom,
    ! [VarCurr] :
      ( v993(VarCurr)
    <=> v969(VarCurr) ) ).

fof(addAssignment_201,axiom,
    ! [VarCurr] :
      ( v992(VarCurr)
    <=> v112(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_162,axiom,
    ! [VarCurr] :
      ( v963(VarCurr)
    <=> ( v964(VarCurr)
        | v981(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_161,axiom,
    ! [VarCurr] :
      ( v981(VarCurr)
    <=> ( v982(VarCurr)
        & v776(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_160,axiom,
    ! [VarCurr] :
      ( v982(VarCurr)
    <=> ( v983(VarCurr)
        | v985(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_159,axiom,
    ! [VarCurr] :
      ( v985(VarCurr)
    <=> ( v987(VarCurr)
        & v980(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_158,axiom,
    ! [VarCurr] :
      ( v987(VarCurr)
    <=> ( v988(VarCurr)
        & v979(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_157,axiom,
    ! [VarCurr] :
      ( v988(VarCurr)
    <=> ( v976(VarCurr)
        & v616(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_156,axiom,
    ! [VarCurr] :
      ( v983(VarCurr)
    <=> ( v969(VarCurr)
        & v616(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_155,axiom,
    ! [VarCurr] :
      ( v969(VarCurr)
    <=> ( v970(VarCurr)
        & v885(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_154,axiom,
    ! [VarCurr] :
      ( v964(VarCurr)
    <=> ( v965(VarCurr)
        & v886(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_153,axiom,
    ! [VarCurr] :
      ( v965(VarCurr)
    <=> ( v966(VarCurr)
        | v973(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_152,axiom,
    ! [VarCurr] :
      ( v973(VarCurr)
    <=> ( v975(VarCurr)
        & v980(VarCurr) ) ) ).

fof(writeUnaryOperator_65,axiom,
    ! [VarCurr] :
      ( ~ v980(VarCurr)
    <=> v283(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_151,axiom,
    ! [VarCurr] :
      ( v975(VarCurr)
    <=> ( v976(VarCurr)
        & v979(VarCurr) ) ) ).

fof(writeUnaryOperator_64,axiom,
    ! [VarCurr] :
      ( ~ v979(VarCurr)
    <=> v510(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_150,axiom,
    ! [VarCurr] :
      ( v976(VarCurr)
    <=> ( v977(VarCurr)
        & v885(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_149,axiom,
    ! [VarCurr] :
      ( v977(VarCurr)
    <=> ( v978(VarCurr)
        & v884(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_148,axiom,
    ! [VarCurr] :
      ( v978(VarCurr)
    <=> ( v208(VarCurr)
        & v972(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_147,axiom,
    ! [VarCurr] :
      ( v966(VarCurr)
    <=> ( v967(VarCurr)
        | v968(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_146,axiom,
    ! [VarCurr] :
      ( v968(VarCurr)
    <=> ( v970(VarCurr)
        & v885(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_145,axiom,
    ! [VarCurr] :
      ( v970(VarCurr)
    <=> ( v971(VarCurr)
        & v884(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_144,axiom,
    ! [VarCurr] :
      ( v971(VarCurr)
    <=> ( v883(VarCurr)
        & v972(VarCurr) ) ) ).

fof(writeUnaryOperator_63,axiom,
    ! [VarCurr] :
      ( ~ v972(VarCurr)
    <=> v257(VarCurr) ) ).

fof(addAssignment_200,axiom,
    ! [VarCurr] :
      ( v967(VarCurr)
    <=> v112(VarCurr) ) ).

fof(addAssignment_199,axiom,
    ! [VarCurr] :
      ( v616(VarCurr)
    <=> v618(VarCurr) ) ).

fof(addAssignment_198,axiom,
    ! [VarCurr] :
      ( v618(VarCurr)
    <=> v620(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_143,axiom,
    ! [VarCurr] :
      ( v620(VarCurr)
    <=> ( v622(VarCurr)
        & v954(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_19,axiom,
    ! [VarCurr] :
      ( v954(VarCurr)
    <=> ( v756(VarCurr,bitIndex2)
        | v756(VarCurr,bitIndex4) ) ) ).

fof(addAssignment_197,axiom,
    ! [VarNext] :
      ( v756(VarNext,bitIndex4)
    <=> v946(VarNext,bitIndex3) ) ).

fof(addCaseBooleanConditionShiftedRanges1_8,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v947(VarNext)
       => ( ( v946(VarNext,bitIndex3)
          <=> v756(VarCurr,bitIndex4) )
          & ( v946(VarNext,bitIndex2)
          <=> v756(VarCurr,bitIndex3) )
          & ( v946(VarNext,bitIndex1)
          <=> v756(VarCurr,bitIndex2) )
          & ( v946(VarNext,bitIndex0)
          <=> v756(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_13,axiom,
    ! [VarNext] :
      ( v947(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v946(VarNext,B)
          <=> v935(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_142,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v947(VarNext)
      <=> v948(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_141,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v948(VarNext)
      <=> ( v950(VarNext)
          & v922(VarNext) ) ) ) ).

fof(writeUnaryOperator_62,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v950(VarNext)
      <=> v929(VarNext) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_8,axiom,
    ! [VarCurr] :
      ( ~ v940(VarCurr)
     => ( v760(VarCurr,bitIndex4)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_6,axiom,
    ! [VarCurr] :
      ( v940(VarCurr)
     => ( v760(VarCurr,bitIndex4)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_140,axiom,
    ! [VarCurr] :
      ( v940(VarCurr)
    <=> ( v941(VarCurr)
        | v942(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_139,axiom,
    ! [VarCurr] :
      ( v942(VarCurr)
    <=> ( v943(VarCurr)
        & v944(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_39,axiom,
    ! [VarCurr] :
      ( v944(VarCurr)
    <=> ( $true
      <=> v756(VarCurr,bitIndex4) ) ) ).

fof(writeUnaryOperator_61,axiom,
    ! [VarCurr] :
      ( ~ v943(VarCurr)
    <=> v622(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_38,axiom,
    ! [VarCurr] :
      ( v941(VarCurr)
    <=> ( $true
      <=> v756(VarCurr,bitIndex3) ) ) ).

fof(addAssignment_196,axiom,
    ! [VarNext] :
      ( v756(VarNext,bitIndex2)
    <=> v924(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionShiftedRanges1_7,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v925(VarNext)
       => ( ( v924(VarNext,bitIndex3)
          <=> v756(VarCurr,bitIndex4) )
          & ( v924(VarNext,bitIndex2)
          <=> v756(VarCurr,bitIndex3) )
          & ( v924(VarNext,bitIndex1)
          <=> v756(VarCurr,bitIndex2) )
          & ( v924(VarNext,bitIndex0)
          <=> v756(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_12,axiom,
    ! [VarNext] :
      ( v925(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v924(VarNext,B)
          <=> v935(VarNext,B) ) ) ) ).

fof(addAssignment_195,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v935(VarNext,B)
          <=> v933(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_7,axiom,
    ! [VarCurr] :
      ( ~ v936(VarCurr)
     => ( ( v933(VarCurr,bitIndex3)
        <=> v760(VarCurr,bitIndex4) )
        & ( v933(VarCurr,bitIndex2)
        <=> v760(VarCurr,bitIndex3) )
        & ( v933(VarCurr,bitIndex1)
        <=> v760(VarCurr,bitIndex2) )
        & ( v933(VarCurr,bitIndex0)
        <=> v760(VarCurr,bitIndex1) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_10,axiom,
    ! [VarCurr] :
      ( v936(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v933(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_60,axiom,
    ! [VarCurr] :
      ( ~ v936(VarCurr)
    <=> v758(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_138,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v925(VarNext)
      <=> v926(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_137,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v926(VarNext)
      <=> ( v927(VarNext)
          & v922(VarNext) ) ) ) ).

fof(writeUnaryOperator_59,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v927(VarNext)
      <=> v929(VarNext) ) ) ).

fof(addAssignment_194,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v929(VarNext)
      <=> v922(VarCurr) ) ) ).

fof(addAssignment_193,axiom,
    ! [VarCurr] :
      ( v922(VarCurr)
    <=> v303(VarCurr) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_6,axiom,
    ! [VarCurr] :
      ( ~ v915(VarCurr)
     => ( v760(VarCurr,bitIndex2)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_5,axiom,
    ! [VarCurr] :
      ( v915(VarCurr)
     => ( v760(VarCurr,bitIndex2)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_136,axiom,
    ! [VarCurr] :
      ( v915(VarCurr)
    <=> ( v916(VarCurr)
        | v917(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_135,axiom,
    ! [VarCurr] :
      ( v917(VarCurr)
    <=> ( v918(VarCurr)
        & v920(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_37,axiom,
    ! [VarCurr] :
      ( v920(VarCurr)
    <=> ( $true
      <=> v756(VarCurr,bitIndex2) ) ) ).

fof(writeUnaryOperator_58,axiom,
    ! [VarCurr] :
      ( ~ v918(VarCurr)
    <=> v622(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_36,axiom,
    ! [VarCurr] :
      ( v916(VarCurr)
    <=> ( $true
      <=> v756(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_192,axiom,
    ! [VarCurr,B] :
      ( range_1_0(B)
     => ( v906(VarCurr,B)
      <=> v908(VarCurr,B) ) ) ).

fof(addAssignment_191,axiom,
    ! [VarCurr,B] :
      ( range_1_0(B)
     => ( v908(VarCurr,B)
      <=> v910(VarCurr,B) ) ) ).

fof(addAssignment_190,axiom,
    ! [VarCurr] :
      ( v910(VarCurr,bitIndex0)
    <=> v110(VarCurr,bitIndex4) ) ).

fof(addAssignment_189,axiom,
    ! [VarCurr] :
      ( v910(VarCurr,bitIndex1)
    <=> v912(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_18,axiom,
    ! [VarCurr] :
      ( v912(VarCurr)
    <=> ( v110(VarCurr,bitIndex1)
        | v110(VarCurr,bitIndex7) ) ) ).

fof(addAssignment_188,axiom,
    ! [VarCurr] :
      ( v762(VarCurr)
    <=> v764(VarCurr) ) ).

fof(addAssignment_187,axiom,
    ! [VarCurr] :
      ( v764(VarCurr)
    <=> v766(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_17,axiom,
    ! [VarCurr] :
      ( v766(VarCurr)
    <=> ( v904(VarCurr)
        | v110(VarCurr,bitIndex7) ) ) ).

fof(writeBinaryOperatorShiftedRanges_16,axiom,
    ! [VarCurr] :
      ( v904(VarCurr)
    <=> ( v110(VarCurr,bitIndex1)
        | v110(VarCurr,bitIndex4) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_5,axiom,
    ! [VarCurr] :
      ( ~ v871(VarCurr)
     => ( v110(VarCurr,bitIndex4)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_4,axiom,
    ! [VarCurr] :
      ( v871(VarCurr)
     => ( v110(VarCurr,bitIndex4)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_134,axiom,
    ! [VarCurr] :
      ( v871(VarCurr)
    <=> ( v872(VarCurr)
        | v901(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_133,axiom,
    ! [VarCurr] :
      ( v901(VarCurr)
    <=> ( v902(VarCurr)
        & v861(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_132,axiom,
    ! [VarCurr] :
      ( v902(VarCurr)
    <=> ( v880(VarCurr)
        & v516(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_131,axiom,
    ! [VarCurr] :
      ( v872(VarCurr)
    <=> ( v873(VarCurr)
        | v899(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_130,axiom,
    ! [VarCurr] :
      ( v899(VarCurr)
    <=> ( v900(VarCurr)
        & v838(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_129,axiom,
    ! [VarCurr] :
      ( v900(VarCurr)
    <=> ( v890(VarCurr)
        & v516(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_128,axiom,
    ! [VarCurr] :
      ( v873(VarCurr)
    <=> ( v874(VarCurr)
        | v896(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_127,axiom,
    ! [VarCurr] :
      ( v896(VarCurr)
    <=> ( v897(VarCurr)
        & v898(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_35,axiom,
    ! [VarCurr] :
      ( v898(VarCurr)
    <=> ( $true
      <=> v254(VarCurr,bitIndex6) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_126,axiom,
    ! [VarCurr] :
      ( v897(VarCurr)
    <=> ( v880(VarCurr)
        & v516(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_125,axiom,
    ! [VarCurr] :
      ( v874(VarCurr)
    <=> ( v875(VarCurr)
        | v894(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_124,axiom,
    ! [VarCurr] :
      ( v894(VarCurr)
    <=> ( v895(VarCurr)
        & v816(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_123,axiom,
    ! [VarCurr] :
      ( v895(VarCurr)
    <=> ( v890(VarCurr)
        & v516(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_122,axiom,
    ! [VarCurr] :
      ( v875(VarCurr)
    <=> ( v876(VarCurr)
        | v891(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_121,axiom,
    ! [VarCurr] :
      ( v891(VarCurr)
    <=> ( v892(VarCurr)
        & v893(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_34,axiom,
    ! [VarCurr] :
      ( v893(VarCurr)
    <=> ( $true
      <=> v254(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_120,axiom,
    ! [VarCurr] :
      ( v892(VarCurr)
    <=> ( v880(VarCurr)
        & v516(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_119,axiom,
    ! [VarCurr] :
      ( v876(VarCurr)
    <=> ( v877(VarCurr)
        | v887(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_118,axiom,
    ! [VarCurr] :
      ( v887(VarCurr)
    <=> ( v888(VarCurr)
        & v776(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_117,axiom,
    ! [VarCurr] :
      ( v888(VarCurr)
    <=> ( v890(VarCurr)
        & v516(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_116,axiom,
    ! [VarCurr] :
      ( v890(VarCurr)
    <=> ( v880(VarCurr)
        & v616(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_115,axiom,
    ! [VarCurr] :
      ( v877(VarCurr)
    <=> ( v878(VarCurr)
        & v886(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_33,axiom,
    ! [VarCurr] :
      ( v886(VarCurr)
    <=> ( $true
      <=> v254(VarCurr,bitIndex0) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_114,axiom,
    ! [VarCurr] :
      ( v878(VarCurr)
    <=> ( v880(VarCurr)
        & v516(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_113,axiom,
    ! [VarCurr] :
      ( v880(VarCurr)
    <=> ( v881(VarCurr)
        & v885(VarCurr) ) ) ).

fof(writeUnaryOperator_57,axiom,
    ! [VarCurr] :
      ( ~ v885(VarCurr)
    <=> v112(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_112,axiom,
    ! [VarCurr] :
      ( v881(VarCurr)
    <=> ( v882(VarCurr)
        & v884(VarCurr) ) ) ).

fof(writeUnaryOperator_56,axiom,
    ! [VarCurr] :
      ( ~ v884(VarCurr)
    <=> v279(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_111,axiom,
    ! [VarCurr] :
      ( v882(VarCurr)
    <=> ( v883(VarCurr)
        & v257(VarCurr) ) ) ).

fof(writeUnaryOperator_55,axiom,
    ! [VarCurr] :
      ( ~ v883(VarCurr)
    <=> v208(VarCurr) ) ).

fof(addAssignment_186,axiom,
    ! [VarNext] :
      ( v254(VarNext,bitIndex9)
    <=> v863(VarNext,bitIndex8) ) ).

fof(addCaseBooleanConditionShiftedRanges1_6,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v864(VarNext)
       => ( ( v863(VarNext,bitIndex10)
          <=> v254(VarCurr,bitIndex11) )
          & ( v863(VarNext,bitIndex9)
          <=> v254(VarCurr,bitIndex10) )
          & ( v863(VarNext,bitIndex8)
          <=> v254(VarCurr,bitIndex9) )
          & ( v863(VarNext,bitIndex7)
          <=> v254(VarCurr,bitIndex8) )
          & ( v863(VarNext,bitIndex6)
          <=> v254(VarCurr,bitIndex7) )
          & ( v863(VarNext,bitIndex5)
          <=> v254(VarCurr,bitIndex6) )
          & ( v863(VarNext,bitIndex4)
          <=> v254(VarCurr,bitIndex5) )
          & ( v863(VarNext,bitIndex3)
          <=> v254(VarCurr,bitIndex4) )
          & ( v863(VarNext,bitIndex2)
          <=> v254(VarCurr,bitIndex3) )
          & ( v863(VarNext,bitIndex1)
          <=> v254(VarCurr,bitIndex2) )
          & ( v863(VarNext,bitIndex0)
          <=> v254(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_11,axiom,
    ! [VarNext] :
      ( v864(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v863(VarNext,B)
          <=> v791(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_110,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v864(VarNext)
      <=> v865(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_109,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v865(VarNext)
      <=> ( v867(VarNext)
          & v778(VarNext) ) ) ) ).

fof(writeUnaryOperator_54,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v867(VarNext)
      <=> v785(VarNext) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_4,axiom,
    ! [VarCurr] :
      ( ~ v849(VarCurr)
     => ( v110(VarCurr,bitIndex9)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_3,axiom,
    ! [VarCurr] :
      ( v849(VarCurr)
     => ( v110(VarCurr,bitIndex9)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_108,axiom,
    ! [VarCurr] :
      ( v849(VarCurr)
    <=> ( v850(VarCurr)
        | v859(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_107,axiom,
    ! [VarCurr] :
      ( v859(VarCurr)
    <=> ( v860(VarCurr)
        & v861(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_32,axiom,
    ! [VarCurr] :
      ( v861(VarCurr)
    <=> ( $true
      <=> v254(VarCurr,bitIndex9) ) ) ).

fof(addAssignment_185,axiom,
    ! [VarCurr] :
      ( v860(VarCurr)
    <=> v112(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_106,axiom,
    ! [VarCurr] :
      ( v850(VarCurr)
    <=> ( v851(VarCurr)
        | v857(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_105,axiom,
    ! [VarCurr] :
      ( v857(VarCurr)
    <=> ( v858(VarCurr)
        & v838(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_104,axiom,
    ! [VarCurr] :
      ( v858(VarCurr)
    <=> ( v112(VarCurr)
        & v616(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_103,axiom,
    ! [VarCurr] :
      ( v851(VarCurr)
    <=> ( v852(VarCurr)
        | v855(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_102,axiom,
    ! [VarCurr] :
      ( v855(VarCurr)
    <=> ( v856(VarCurr)
        & v816(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_101,axiom,
    ! [VarCurr] :
      ( v856(VarCurr)
    <=> ( v112(VarCurr)
        & v616(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_100,axiom,
    ! [VarCurr] :
      ( v852(VarCurr)
    <=> ( v853(VarCurr)
        & v776(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_99,axiom,
    ! [VarCurr] :
      ( v853(VarCurr)
    <=> ( v112(VarCurr)
        & v616(VarCurr) ) ) ).

fof(addAssignment_184,axiom,
    ! [VarNext] :
      ( v254(VarNext,bitIndex8)
    <=> v840(VarNext,bitIndex7) ) ).

fof(addCaseBooleanConditionShiftedRanges1_5,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v841(VarNext)
       => ( ( v840(VarNext,bitIndex10)
          <=> v254(VarCurr,bitIndex11) )
          & ( v840(VarNext,bitIndex9)
          <=> v254(VarCurr,bitIndex10) )
          & ( v840(VarNext,bitIndex8)
          <=> v254(VarCurr,bitIndex9) )
          & ( v840(VarNext,bitIndex7)
          <=> v254(VarCurr,bitIndex8) )
          & ( v840(VarNext,bitIndex6)
          <=> v254(VarCurr,bitIndex7) )
          & ( v840(VarNext,bitIndex5)
          <=> v254(VarCurr,bitIndex6) )
          & ( v840(VarNext,bitIndex4)
          <=> v254(VarCurr,bitIndex5) )
          & ( v840(VarNext,bitIndex3)
          <=> v254(VarCurr,bitIndex4) )
          & ( v840(VarNext,bitIndex2)
          <=> v254(VarCurr,bitIndex3) )
          & ( v840(VarNext,bitIndex1)
          <=> v254(VarCurr,bitIndex2) )
          & ( v840(VarNext,bitIndex0)
          <=> v254(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_10,axiom,
    ! [VarNext] :
      ( v841(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v840(VarNext,B)
          <=> v791(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_98,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v841(VarNext)
      <=> v842(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_97,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v842(VarNext)
      <=> ( v844(VarNext)
          & v778(VarNext) ) ) ) ).

fof(writeUnaryOperator_53,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v844(VarNext)
      <=> v785(VarNext) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_3,axiom,
    ! [VarCurr] :
      ( ~ v834(VarCurr)
     => ( v110(VarCurr,bitIndex8)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_2,axiom,
    ! [VarCurr] :
      ( v834(VarCurr)
     => ( v110(VarCurr,bitIndex8)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_96,axiom,
    ! [VarCurr] :
      ( v834(VarCurr)
    <=> ( v835(VarCurr)
        | v836(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_95,axiom,
    ! [VarCurr] :
      ( v836(VarCurr)
    <=> ( v837(VarCurr)
        & v838(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_31,axiom,
    ! [VarCurr] :
      ( v838(VarCurr)
    <=> ( $true
      <=> v254(VarCurr,bitIndex8) ) ) ).

fof(writeUnaryOperator_52,axiom,
    ! [VarCurr] :
      ( ~ v837(VarCurr)
    <=> v616(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_30,axiom,
    ! [VarCurr] :
      ( v835(VarCurr)
    <=> ( $true
      <=> v254(VarCurr,bitIndex7) ) ) ).

fof(addAssignment_183,axiom,
    ! [VarNext] :
      ( v254(VarNext,bitIndex6)
    <=> v826(VarNext,bitIndex5) ) ).

fof(addCaseBooleanConditionShiftedRanges1_4,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v827(VarNext)
       => ( ( v826(VarNext,bitIndex10)
          <=> v254(VarCurr,bitIndex11) )
          & ( v826(VarNext,bitIndex9)
          <=> v254(VarCurr,bitIndex10) )
          & ( v826(VarNext,bitIndex8)
          <=> v254(VarCurr,bitIndex9) )
          & ( v826(VarNext,bitIndex7)
          <=> v254(VarCurr,bitIndex8) )
          & ( v826(VarNext,bitIndex6)
          <=> v254(VarCurr,bitIndex7) )
          & ( v826(VarNext,bitIndex5)
          <=> v254(VarCurr,bitIndex6) )
          & ( v826(VarNext,bitIndex4)
          <=> v254(VarCurr,bitIndex5) )
          & ( v826(VarNext,bitIndex3)
          <=> v254(VarCurr,bitIndex4) )
          & ( v826(VarNext,bitIndex2)
          <=> v254(VarCurr,bitIndex3) )
          & ( v826(VarNext,bitIndex1)
          <=> v254(VarCurr,bitIndex2) )
          & ( v826(VarNext,bitIndex0)
          <=> v254(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_9,axiom,
    ! [VarNext] :
      ( v827(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v826(VarNext,B)
          <=> v791(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_94,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v827(VarNext)
      <=> v828(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_93,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v828(VarNext)
      <=> ( v830(VarNext)
          & v778(VarNext) ) ) ) ).

fof(writeUnaryOperator_51,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v830(VarNext)
      <=> v785(VarNext) ) ) ).

fof(addAssignment_182,axiom,
    ! [VarNext] :
      ( v254(VarNext,bitIndex5)
    <=> v818(VarNext,bitIndex4) ) ).

fof(addCaseBooleanConditionShiftedRanges1_3,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v819(VarNext)
       => ( ( v818(VarNext,bitIndex10)
          <=> v254(VarCurr,bitIndex11) )
          & ( v818(VarNext,bitIndex9)
          <=> v254(VarCurr,bitIndex10) )
          & ( v818(VarNext,bitIndex8)
          <=> v254(VarCurr,bitIndex9) )
          & ( v818(VarNext,bitIndex7)
          <=> v254(VarCurr,bitIndex8) )
          & ( v818(VarNext,bitIndex6)
          <=> v254(VarCurr,bitIndex7) )
          & ( v818(VarNext,bitIndex5)
          <=> v254(VarCurr,bitIndex6) )
          & ( v818(VarNext,bitIndex4)
          <=> v254(VarCurr,bitIndex5) )
          & ( v818(VarNext,bitIndex3)
          <=> v254(VarCurr,bitIndex4) )
          & ( v818(VarNext,bitIndex2)
          <=> v254(VarCurr,bitIndex3) )
          & ( v818(VarNext,bitIndex1)
          <=> v254(VarCurr,bitIndex2) )
          & ( v818(VarNext,bitIndex0)
          <=> v254(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_8,axiom,
    ! [VarNext] :
      ( v819(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v818(VarNext,B)
          <=> v791(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_92,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v819(VarNext)
      <=> v820(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_91,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v820(VarNext)
      <=> ( v822(VarNext)
          & v778(VarNext) ) ) ) ).

fof(writeUnaryOperator_50,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v822(VarNext)
      <=> v785(VarNext) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_2,axiom,
    ! [VarCurr] :
      ( ~ v812(VarCurr)
     => ( v110(VarCurr,bitIndex5)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch_1,axiom,
    ! [VarCurr] :
      ( v812(VarCurr)
     => ( v110(VarCurr,bitIndex5)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_90,axiom,
    ! [VarCurr] :
      ( v812(VarCurr)
    <=> ( v813(VarCurr)
        | v814(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_89,axiom,
    ! [VarCurr] :
      ( v814(VarCurr)
    <=> ( v815(VarCurr)
        & v816(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_29,axiom,
    ! [VarCurr] :
      ( v816(VarCurr)
    <=> ( $true
      <=> v254(VarCurr,bitIndex5) ) ) ).

fof(writeUnaryOperator_49,axiom,
    ! [VarCurr] :
      ( ~ v815(VarCurr)
    <=> v616(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_28,axiom,
    ! [VarCurr] :
      ( v813(VarCurr)
    <=> ( $true
      <=> v254(VarCurr,bitIndex4) ) ) ).

fof(addAssignment_181,axiom,
    ! [VarNext] :
      ( v254(VarNext,bitIndex4)
    <=> v804(VarNext,bitIndex3) ) ).

fof(addCaseBooleanConditionShiftedRanges1_2,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v805(VarNext)
       => ( ( v804(VarNext,bitIndex10)
          <=> v254(VarCurr,bitIndex11) )
          & ( v804(VarNext,bitIndex9)
          <=> v254(VarCurr,bitIndex10) )
          & ( v804(VarNext,bitIndex8)
          <=> v254(VarCurr,bitIndex9) )
          & ( v804(VarNext,bitIndex7)
          <=> v254(VarCurr,bitIndex8) )
          & ( v804(VarNext,bitIndex6)
          <=> v254(VarCurr,bitIndex7) )
          & ( v804(VarNext,bitIndex5)
          <=> v254(VarCurr,bitIndex6) )
          & ( v804(VarNext,bitIndex4)
          <=> v254(VarCurr,bitIndex5) )
          & ( v804(VarNext,bitIndex3)
          <=> v254(VarCurr,bitIndex4) )
          & ( v804(VarNext,bitIndex2)
          <=> v254(VarCurr,bitIndex3) )
          & ( v804(VarNext,bitIndex1)
          <=> v254(VarCurr,bitIndex2) )
          & ( v804(VarNext,bitIndex0)
          <=> v254(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_7,axiom,
    ! [VarNext] :
      ( v805(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v804(VarNext,B)
          <=> v791(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_88,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v805(VarNext)
      <=> v806(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_87,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v806(VarNext)
      <=> ( v808(VarNext)
          & v778(VarNext) ) ) ) ).

fof(writeUnaryOperator_48,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v808(VarNext)
      <=> v785(VarNext) ) ) ).

fof(addAssignment_180,axiom,
    ! [VarNext] :
      ( v254(VarNext,bitIndex3)
    <=> v796(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionShiftedRanges1_1,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v797(VarNext)
       => ( ( v796(VarNext,bitIndex10)
          <=> v254(VarCurr,bitIndex11) )
          & ( v796(VarNext,bitIndex9)
          <=> v254(VarCurr,bitIndex10) )
          & ( v796(VarNext,bitIndex8)
          <=> v254(VarCurr,bitIndex9) )
          & ( v796(VarNext,bitIndex7)
          <=> v254(VarCurr,bitIndex8) )
          & ( v796(VarNext,bitIndex6)
          <=> v254(VarCurr,bitIndex7) )
          & ( v796(VarNext,bitIndex5)
          <=> v254(VarCurr,bitIndex6) )
          & ( v796(VarNext,bitIndex4)
          <=> v254(VarCurr,bitIndex5) )
          & ( v796(VarNext,bitIndex3)
          <=> v254(VarCurr,bitIndex4) )
          & ( v796(VarNext,bitIndex2)
          <=> v254(VarCurr,bitIndex3) )
          & ( v796(VarNext,bitIndex1)
          <=> v254(VarCurr,bitIndex2) )
          & ( v796(VarNext,bitIndex0)
          <=> v254(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_6,axiom,
    ! [VarNext] :
      ( v797(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v796(VarNext,B)
          <=> v791(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_86,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v797(VarNext)
      <=> v798(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_85,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v798(VarNext)
      <=> ( v800(VarNext)
          & v778(VarNext) ) ) ) ).

fof(writeUnaryOperator_47,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v800(VarNext)
      <=> v785(VarNext) ) ) ).

fof(addAssignment_179,axiom,
    ! [VarNext] :
      ( v254(VarNext,bitIndex2)
    <=> v780(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionShiftedRanges1,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v781(VarNext)
       => ( ( v780(VarNext,bitIndex10)
          <=> v254(VarCurr,bitIndex11) )
          & ( v780(VarNext,bitIndex9)
          <=> v254(VarCurr,bitIndex10) )
          & ( v780(VarNext,bitIndex8)
          <=> v254(VarCurr,bitIndex9) )
          & ( v780(VarNext,bitIndex7)
          <=> v254(VarCurr,bitIndex8) )
          & ( v780(VarNext,bitIndex6)
          <=> v254(VarCurr,bitIndex7) )
          & ( v780(VarNext,bitIndex5)
          <=> v254(VarCurr,bitIndex6) )
          & ( v780(VarNext,bitIndex4)
          <=> v254(VarCurr,bitIndex5) )
          & ( v780(VarNext,bitIndex3)
          <=> v254(VarCurr,bitIndex4) )
          & ( v780(VarNext,bitIndex2)
          <=> v254(VarCurr,bitIndex3) )
          & ( v780(VarNext,bitIndex1)
          <=> v254(VarCurr,bitIndex2) )
          & ( v780(VarNext,bitIndex0)
          <=> v254(VarCurr,bitIndex1) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_5,axiom,
    ! [VarNext] :
      ( v781(VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v780(VarNext,B)
          <=> v791(VarNext,B) ) ) ) ).

fof(addAssignment_178,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_10_0(B)
         => ( v791(VarNext,B)
          <=> v789(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch_1,axiom,
    ! [VarCurr] :
      ( ~ v792(VarCurr)
     => ( ( v789(VarCurr,bitIndex10)
        <=> v110(VarCurr,bitIndex11) )
        & ( v789(VarCurr,bitIndex9)
        <=> v110(VarCurr,bitIndex10) )
        & ( v789(VarCurr,bitIndex8)
        <=> v110(VarCurr,bitIndex9) )
        & ( v789(VarCurr,bitIndex7)
        <=> v110(VarCurr,bitIndex8) )
        & ( v789(VarCurr,bitIndex6)
        <=> v110(VarCurr,bitIndex7) )
        & ( v789(VarCurr,bitIndex5)
        <=> v110(VarCurr,bitIndex6) )
        & ( v789(VarCurr,bitIndex4)
        <=> v110(VarCurr,bitIndex5) )
        & ( v789(VarCurr,bitIndex3)
        <=> v110(VarCurr,bitIndex4) )
        & ( v789(VarCurr,bitIndex2)
        <=> v110(VarCurr,bitIndex3) )
        & ( v789(VarCurr,bitIndex1)
        <=> v110(VarCurr,bitIndex2) )
        & ( v789(VarCurr,bitIndex0)
        <=> v110(VarCurr,bitIndex1) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_9,axiom,
    ! [VarCurr] :
      ( v792(VarCurr)
     => ! [B] :
          ( range_10_0(B)
         => ( v789(VarCurr,B)
          <=> $false ) ) ) ).

fof(bitBlastConstant_190,axiom,
    ~ b00000000000(bitIndex10) ).

fof(bitBlastConstant_189,axiom,
    ~ b00000000000(bitIndex9) ).

fof(bitBlastConstant_188,axiom,
    ~ b00000000000(bitIndex8) ).

fof(bitBlastConstant_187,axiom,
    ~ b00000000000(bitIndex7) ).

fof(bitBlastConstant_186,axiom,
    ~ b00000000000(bitIndex6) ).

fof(bitBlastConstant_185,axiom,
    ~ b00000000000(bitIndex5) ).

fof(bitBlastConstant_184,axiom,
    ~ b00000000000(bitIndex4) ).

fof(bitBlastConstant_183,axiom,
    ~ b00000000000(bitIndex3) ).

fof(bitBlastConstant_182,axiom,
    ~ b00000000000(bitIndex2) ).

fof(bitBlastConstant_181,axiom,
    ~ b00000000000(bitIndex1) ).

fof(bitBlastConstant_180,axiom,
    ~ b00000000000(bitIndex0) ).

fof(writeUnaryOperator_46,axiom,
    ! [VarCurr] :
      ( ~ v792(VarCurr)
    <=> v102(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_84,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v781(VarNext)
      <=> v782(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_83,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v782(VarNext)
      <=> ( v783(VarNext)
          & v778(VarNext) ) ) ) ).

fof(writeUnaryOperator_45,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v783(VarNext)
      <=> v785(VarNext) ) ) ).

fof(addAssignment_177,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v785(VarNext)
      <=> v778(VarCurr) ) ) ).

fof(addAssignment_176,axiom,
    ! [VarCurr] :
      ( v778(VarCurr)
    <=> v303(VarCurr) ) ).

fof(addConditionBooleanCondShiftedRangesElseBranch,axiom,
    ! [VarCurr] :
      ( ~ v771(VarCurr)
     => ( v110(VarCurr,bitIndex2)
      <=> $false ) ) ).

fof(addConditionBooleanCondShiftedRangesThenBranch,axiom,
    ! [VarCurr] :
      ( v771(VarCurr)
     => ( v110(VarCurr,bitIndex2)
      <=> $true ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_82,axiom,
    ! [VarCurr] :
      ( v771(VarCurr)
    <=> ( v772(VarCurr)
        | v773(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_81,axiom,
    ! [VarCurr] :
      ( v773(VarCurr)
    <=> ( v774(VarCurr)
        & v776(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_27,axiom,
    ! [VarCurr] :
      ( v776(VarCurr)
    <=> ( $true
      <=> v254(VarCurr,bitIndex2) ) ) ).

fof(writeUnaryOperator_44,axiom,
    ! [VarCurr] :
      ( ~ v774(VarCurr)
    <=> v616(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_26,axiom,
    ! [VarCurr] :
      ( v772(VarCurr)
    <=> ( $true
      <=> v254(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_175,axiom,
    ! [VarCurr] :
      ( v758(VarCurr)
    <=> v104(VarCurr) ) ).

fof(addAssignment_174,axiom,
    ! [VarCurr] :
      ( v622(VarCurr)
    <=> v624(VarCurr) ) ).

fof(addAssignment_173,axiom,
    ! [VarCurr] :
      ( v624(VarCurr)
    <=> v626(VarCurr) ) ).

fof(addAssignment_172,axiom,
    ! [VarCurr] :
      ( v626(VarCurr)
    <=> v628(VarCurr) ) ).

fof(addAssignment_171,axiom,
    ! [VarCurr] :
      ( v628(VarCurr)
    <=> v630(VarCurr) ) ).

fof(addAssignment_170,axiom,
    ! [VarCurr] :
      ( v630(VarCurr)
    <=> v632(VarCurr) ) ).

fof(addCaseBooleanConditionEqualRanges1_4,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v741(VarNext)
       => ( v632(VarNext)
        <=> v632(VarCurr) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_4,axiom,
    ! [VarNext] :
      ( v741(VarNext)
     => ( v632(VarNext)
      <=> v751(VarNext) ) ) ).

fof(addAssignment_169,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v751(VarNext)
      <=> v749(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_8,axiom,
    ! [VarCurr] :
      ( ~ v752(VarCurr)
     => ( v749(VarCurr)
      <=> v638(VarCurr) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_8,axiom,
    ! [VarCurr] :
      ( v752(VarCurr)
     => ( v749(VarCurr)
      <=> $false ) ) ).

fof(writeUnaryOperator_43,axiom,
    ! [VarCurr] :
      ( ~ v752(VarCurr)
    <=> v634(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_80,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v741(VarNext)
      <=> v742(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_79,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v742(VarNext)
      <=> ( v743(VarNext)
          & v736(VarNext) ) ) ) ).

fof(writeUnaryOperator_42,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v743(VarNext)
      <=> v745(VarNext) ) ) ).

fof(addAssignment_168,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v745(VarNext)
      <=> v736(VarCurr) ) ) ).

fof(addAssignment_167,axiom,
    ! [VarCurr] :
      ( v736(VarCurr)
    <=> v738(VarCurr) ) ).

fof(addAssignment_166,axiom,
    ! [VarCurr] :
      ( v738(VarCurr)
    <=> v1(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_7,axiom,
    ! [VarCurr] :
      ( ~ v680(VarCurr)
     => ( v638(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_7,axiom,
    ! [VarCurr] :
      ( v680(VarCurr)
     => ( v638(VarCurr)
      <=> v717(VarCurr) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_3,axiom,
    ! [VarCurr] :
      ( ~ v691(VarCurr)
     => ( v717(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_3,axiom,
    ! [VarCurr] :
      ( v691(VarCurr)
     => ( v717(VarCurr)
      <=> v718(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_78,axiom,
    ! [VarCurr] :
      ( v724(VarCurr)
    <=> ( v726(VarCurr)
        | v706(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_77,axiom,
    ! [VarCurr] :
      ( v726(VarCurr)
    <=> ( v727(VarCurr)
        | v703(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_76,axiom,
    ! [VarCurr] :
      ( v727(VarCurr)
    <=> ( v728(VarCurr)
        | v696(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_75,axiom,
    ! [VarCurr] :
      ( v728(VarCurr)
    <=> ( v729(VarCurr)
        | v702(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_74,axiom,
    ! [VarCurr] :
      ( v729(VarCurr)
    <=> ( v730(VarCurr)
        | v701(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_73,axiom,
    ! [VarCurr] :
      ( v730(VarCurr)
    <=> ( v731(VarCurr)
        | v700(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_72,axiom,
    ! [VarCurr] :
      ( v731(VarCurr)
    <=> ( v732(VarCurr)
        | v699(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_71,axiom,
    ! [VarCurr] :
      ( v732(VarCurr)
    <=> ( v733(VarCurr)
        | v695(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_70,axiom,
    ! [VarCurr] :
      ( v733(VarCurr)
    <=> ( v734(VarCurr)
        | v694(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_69,axiom,
    ! [VarCurr] :
      ( v734(VarCurr)
    <=> ( v692(VarCurr)
        | v693(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_6,axiom,
    ! [VarCurr] :
      ( ~ v654(VarCurr)
     => ( v718(VarCurr)
      <=> $false ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_6,axiom,
    ! [VarCurr] :
      ( v654(VarCurr)
     => ( v718(VarCurr)
      <=> v719(VarCurr) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_5,axiom,
    ! [VarCurr] :
      ( ~ v720(VarCurr)
     => ( v719(VarCurr)
      <=> $true ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_5,axiom,
    ! [VarCurr] :
      ( v720(VarCurr)
     => ( v719(VarCurr)
      <=> $false ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_68,axiom,
    ! [VarCurr] :
      ( v720(VarCurr)
    <=> ( v721(VarCurr)
        & v678(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_67,axiom,
    ! [VarCurr] :
      ( v721(VarCurr)
    <=> ( v722(VarCurr)
        | v723(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_25,axiom,
    ! [VarCurr] :
      ( v723(VarCurr)
    <=> ( ( v666(VarCurr,bitIndex3)
        <=> $true )
        & ( v666(VarCurr,bitIndex2)
        <=> $true )
        & ( v666(VarCurr,bitIndex1)
        <=> $false )
        & ( v666(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addBitVectorEqualityBitBlasted_24,axiom,
    ! [VarCurr] :
      ( v722(VarCurr)
    <=> ( ( v666(VarCurr,bitIndex3)
        <=> $false )
        & ( v666(VarCurr,bitIndex2)
        <=> $true )
        & ( v666(VarCurr,bitIndex1)
        <=> $false )
        & ( v666(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_66,axiom,
    ! [VarCurr] :
      ( v680(VarCurr)
    <=> ( v681(VarCurr)
        | v706(VarCurr) ) ) ).

fof(writeUnaryOperator_41,axiom,
    ! [VarCurr] :
      ( ~ v706(VarCurr)
    <=> v707(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_65,axiom,
    ! [VarCurr] :
      ( v707(VarCurr)
    <=> ( v708(VarCurr)
        | v705(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_64,axiom,
    ! [VarCurr] :
      ( v708(VarCurr)
    <=> ( v709(VarCurr)
        | v702(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_63,axiom,
    ! [VarCurr] :
      ( v709(VarCurr)
    <=> ( v710(VarCurr)
        | v701(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_62,axiom,
    ! [VarCurr] :
      ( v710(VarCurr)
    <=> ( v711(VarCurr)
        | v700(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_61,axiom,
    ! [VarCurr] :
      ( v711(VarCurr)
    <=> ( v712(VarCurr)
        | v699(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_60,axiom,
    ! [VarCurr] :
      ( v712(VarCurr)
    <=> ( v713(VarCurr)
        | v698(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_59,axiom,
    ! [VarCurr] :
      ( v713(VarCurr)
    <=> ( v714(VarCurr)
        | v695(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_58,axiom,
    ! [VarCurr] :
      ( v714(VarCurr)
    <=> ( v715(VarCurr)
        | v694(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_57,axiom,
    ! [VarCurr] :
      ( v715(VarCurr)
    <=> ( v716(VarCurr)
        | v693(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_56,axiom,
    ! [VarCurr] :
      ( v716(VarCurr)
    <=> ( v691(VarCurr)
        | v692(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_55,axiom,
    ! [VarCurr] :
      ( v681(VarCurr)
    <=> ( v682(VarCurr)
        | v703(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_54,axiom,
    ! [VarCurr] :
      ( v703(VarCurr)
    <=> ( v704(VarCurr)
        & v705(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_23,axiom,
    ! [VarCurr] :
      ( v705(VarCurr)
    <=> ( ( v640(VarCurr,bitIndex3)
        <=> $true )
        & ( v640(VarCurr,bitIndex2)
        <=> $true )
        & ( v640(VarCurr,bitIndex1)
        <=> $false )
        & ( v640(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_179,axiom,
    b1101(bitIndex3) ).

fof(bitBlastConstant_178,axiom,
    b1101(bitIndex2) ).

fof(bitBlastConstant_177,axiom,
    ~ b1101(bitIndex1) ).

fof(bitBlastConstant_176,axiom,
    b1101(bitIndex0) ).

fof(writeUnaryOperator_40,axiom,
    ! [VarCurr] :
      ( ~ v704(VarCurr)
    <=> v646(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_53,axiom,
    ! [VarCurr] :
      ( v682(VarCurr)
    <=> ( v683(VarCurr)
        | v702(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_22,axiom,
    ! [VarCurr] :
      ( v702(VarCurr)
    <=> ( ( v640(VarCurr,bitIndex3)
        <=> $true )
        & ( v640(VarCurr,bitIndex2)
        <=> $true )
        & ( v640(VarCurr,bitIndex1)
        <=> $false )
        & ( v640(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_175,axiom,
    b1100(bitIndex3) ).

fof(bitBlastConstant_174,axiom,
    b1100(bitIndex2) ).

fof(bitBlastConstant_173,axiom,
    ~ b1100(bitIndex1) ).

fof(bitBlastConstant_172,axiom,
    ~ b1100(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_52,axiom,
    ! [VarCurr] :
      ( v683(VarCurr)
    <=> ( v684(VarCurr)
        | v701(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_21,axiom,
    ! [VarCurr] :
      ( v701(VarCurr)
    <=> ( ( v640(VarCurr,bitIndex3)
        <=> $true )
        & ( v640(VarCurr,bitIndex2)
        <=> $false )
        & ( v640(VarCurr,bitIndex1)
        <=> $true )
        & ( v640(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_171,axiom,
    b1011(bitIndex3) ).

fof(bitBlastConstant_170,axiom,
    ~ b1011(bitIndex2) ).

fof(bitBlastConstant_169,axiom,
    b1011(bitIndex1) ).

fof(bitBlastConstant_168,axiom,
    b1011(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_51,axiom,
    ! [VarCurr] :
      ( v684(VarCurr)
    <=> ( v685(VarCurr)
        | v700(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_20,axiom,
    ! [VarCurr] :
      ( v700(VarCurr)
    <=> ( ( v640(VarCurr,bitIndex3)
        <=> $true )
        & ( v640(VarCurr,bitIndex2)
        <=> $false )
        & ( v640(VarCurr,bitIndex1)
        <=> $true )
        & ( v640(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_167,axiom,
    b1010(bitIndex3) ).

fof(bitBlastConstant_166,axiom,
    ~ b1010(bitIndex2) ).

fof(bitBlastConstant_165,axiom,
    b1010(bitIndex1) ).

fof(bitBlastConstant_164,axiom,
    ~ b1010(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_50,axiom,
    ! [VarCurr] :
      ( v685(VarCurr)
    <=> ( v686(VarCurr)
        | v699(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_19,axiom,
    ! [VarCurr] :
      ( v699(VarCurr)
    <=> ( ( v640(VarCurr,bitIndex3)
        <=> $true )
        & ( v640(VarCurr,bitIndex2)
        <=> $false )
        & ( v640(VarCurr,bitIndex1)
        <=> $false )
        & ( v640(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_163,axiom,
    b1001(bitIndex3) ).

fof(bitBlastConstant_162,axiom,
    ~ b1001(bitIndex2) ).

fof(bitBlastConstant_161,axiom,
    ~ b1001(bitIndex1) ).

fof(bitBlastConstant_160,axiom,
    b1001(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_49,axiom,
    ! [VarCurr] :
      ( v686(VarCurr)
    <=> ( v687(VarCurr)
        | v696(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_48,axiom,
    ! [VarCurr] :
      ( v696(VarCurr)
    <=> ( v697(VarCurr)
        & v698(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_18,axiom,
    ! [VarCurr] :
      ( v698(VarCurr)
    <=> ( ( v640(VarCurr,bitIndex3)
        <=> $false )
        & ( v640(VarCurr,bitIndex2)
        <=> $true )
        & ( v640(VarCurr,bitIndex1)
        <=> $false )
        & ( v640(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_159,axiom,
    ~ b0101(bitIndex3) ).

fof(bitBlastConstant_158,axiom,
    b0101(bitIndex2) ).

fof(bitBlastConstant_157,axiom,
    ~ b0101(bitIndex1) ).

fof(bitBlastConstant_156,axiom,
    b0101(bitIndex0) ).

fof(writeUnaryOperator_39,axiom,
    ! [VarCurr] :
      ( ~ v697(VarCurr)
    <=> v646(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_47,axiom,
    ! [VarCurr] :
      ( v687(VarCurr)
    <=> ( v688(VarCurr)
        | v695(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_17,axiom,
    ! [VarCurr] :
      ( v695(VarCurr)
    <=> ( ( v640(VarCurr,bitIndex3)
        <=> $false )
        & ( v640(VarCurr,bitIndex2)
        <=> $true )
        & ( v640(VarCurr,bitIndex1)
        <=> $false )
        & ( v640(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_155,axiom,
    ~ b0100(bitIndex3) ).

fof(bitBlastConstant_154,axiom,
    b0100(bitIndex2) ).

fof(bitBlastConstant_153,axiom,
    ~ b0100(bitIndex1) ).

fof(bitBlastConstant_152,axiom,
    ~ b0100(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_46,axiom,
    ! [VarCurr] :
      ( v688(VarCurr)
    <=> ( v689(VarCurr)
        | v694(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_16,axiom,
    ! [VarCurr] :
      ( v694(VarCurr)
    <=> ( ( v640(VarCurr,bitIndex3)
        <=> $false )
        & ( v640(VarCurr,bitIndex2)
        <=> $false )
        & ( v640(VarCurr,bitIndex1)
        <=> $true )
        & ( v640(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_151,axiom,
    ~ b0011(bitIndex3) ).

fof(bitBlastConstant_150,axiom,
    ~ b0011(bitIndex2) ).

fof(bitBlastConstant_149,axiom,
    b0011(bitIndex1) ).

fof(bitBlastConstant_148,axiom,
    b0011(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_45,axiom,
    ! [VarCurr] :
      ( v689(VarCurr)
    <=> ( v690(VarCurr)
        | v693(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_15,axiom,
    ! [VarCurr] :
      ( v693(VarCurr)
    <=> ( ( v640(VarCurr,bitIndex3)
        <=> $false )
        & ( v640(VarCurr,bitIndex2)
        <=> $false )
        & ( v640(VarCurr,bitIndex1)
        <=> $true )
        & ( v640(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_147,axiom,
    ~ b0010(bitIndex3) ).

fof(bitBlastConstant_146,axiom,
    ~ b0010(bitIndex2) ).

fof(bitBlastConstant_145,axiom,
    b0010(bitIndex1) ).

fof(bitBlastConstant_144,axiom,
    ~ b0010(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_44,axiom,
    ! [VarCurr] :
      ( v690(VarCurr)
    <=> ( v691(VarCurr)
        | v692(VarCurr) ) ) ).

fof(addBitVectorEqualityBitBlasted_14,axiom,
    ! [VarCurr] :
      ( v692(VarCurr)
    <=> ( ( v640(VarCurr,bitIndex3)
        <=> $false )
        & ( v640(VarCurr,bitIndex2)
        <=> $false )
        & ( v640(VarCurr,bitIndex1)
        <=> $false )
        & ( v640(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_143,axiom,
    ~ b0001(bitIndex3) ).

fof(bitBlastConstant_142,axiom,
    ~ b0001(bitIndex2) ).

fof(bitBlastConstant_141,axiom,
    ~ b0001(bitIndex1) ).

fof(bitBlastConstant_140,axiom,
    b0001(bitIndex0) ).

fof(addBitVectorEqualityBitBlasted_13,axiom,
    ! [VarCurr] :
      ( v691(VarCurr)
    <=> ( ( v640(VarCurr,bitIndex3)
        <=> $false )
        & ( v640(VarCurr,bitIndex2)
        <=> $false )
        & ( v640(VarCurr,bitIndex1)
        <=> $false )
        & ( v640(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_165,axiom,
    ! [VarCurr] :
      ( v678(VarCurr)
    <=> $false ) ).

fof(addAssignment_164,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v666(VarCurr,B)
      <=> v668(VarCurr,B) ) ) ).

fof(addAssignment_163,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v668(VarCurr,B)
      <=> v670(VarCurr,B) ) ) ).

fof(addAssignment_162,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v670(VarCurr,B)
      <=> v672(VarCurr,B) ) ) ).

fof(addAssignment_161,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v672(VarCurr,B)
      <=> v674(VarCurr,B) ) ) ).

fof(addAssignment_160,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v674(VarCurr,B)
      <=> v676(VarCurr,B) ) ) ).

fof(addAssignment_159,axiom,
    ! [VarCurr] :
      ( v654(VarCurr)
    <=> v656(VarCurr) ) ).

fof(addAssignment_158,axiom,
    ! [VarCurr] :
      ( v656(VarCurr)
    <=> v658(VarCurr) ) ).

fof(addAssignment_157,axiom,
    ! [VarCurr] :
      ( v658(VarCurr)
    <=> v660(VarCurr) ) ).

fof(addAssignment_156,axiom,
    ! [VarCurr] :
      ( v660(VarCurr)
    <=> v662(VarCurr) ) ).

fof(addAssignment_155,axiom,
    ! [VarCurr] :
      ( v662(VarCurr)
    <=> v664(VarCurr) ) ).

fof(addAssignment_154,axiom,
    ! [VarCurr] :
      ( v634(VarCurr)
    <=> v636(VarCurr) ) ).

fof(addAssignment_153,axiom,
    ! [VarCurr] :
      ( v636(VarCurr)
    <=> v14(VarCurr) ) ).

fof(memoryReadIntoBuffer_1,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v600_range_3_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( address(A)
             => ! [B] :
                  ( A = AssociatedAddressVar
                 => ( range_66_0(B)
                   => ( v598(VarNext,B)
                    <=> v530_array(VarNext,A,B) ) ) ) ) ) ) ).

fof(memoryConstantWriteDisabled_1,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( $true
              & v590(VarNext) )
         => ! [B] :
              ( range_66_0(B)
             => ( v530_array(VarNext,A,B)
              <=> v530_1__array(VarNext,A,B) ) ) ) ) ).

fof(memoryConstantWriteEnabledInsideRange_1,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( $true
            & v590(VarNext) )
         => ! [B] :
              ( range_66_0(B)
             => ( v530_array(VarNext,A,B)
              <=> b0000000000000000000000000000000000000000000000000000000000000000000(B) ) ) ) ) ).

fof(bitBlastConstant_139,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex66) ).

fof(bitBlastConstant_138,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex65) ).

fof(bitBlastConstant_137,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex64) ).

fof(bitBlastConstant_136,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex63) ).

fof(bitBlastConstant_135,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex62) ).

fof(bitBlastConstant_134,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex61) ).

fof(bitBlastConstant_133,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex60) ).

fof(bitBlastConstant_132,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex59) ).

fof(bitBlastConstant_131,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex58) ).

fof(bitBlastConstant_130,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex57) ).

fof(bitBlastConstant_129,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex56) ).

fof(bitBlastConstant_128,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex55) ).

fof(bitBlastConstant_127,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex54) ).

fof(bitBlastConstant_126,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex53) ).

fof(bitBlastConstant_125,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex52) ).

fof(bitBlastConstant_124,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex51) ).

fof(bitBlastConstant_123,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex50) ).

fof(bitBlastConstant_122,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex49) ).

fof(bitBlastConstant_121,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex48) ).

fof(bitBlastConstant_120,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex47) ).

fof(bitBlastConstant_119,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex46) ).

fof(bitBlastConstant_118,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex45) ).

fof(bitBlastConstant_117,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex44) ).

fof(bitBlastConstant_116,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex43) ).

fof(bitBlastConstant_115,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex42) ).

fof(bitBlastConstant_114,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex41) ).

fof(bitBlastConstant_113,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex40) ).

fof(bitBlastConstant_112,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex39) ).

fof(bitBlastConstant_111,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex38) ).

fof(bitBlastConstant_110,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex37) ).

fof(bitBlastConstant_109,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex36) ).

fof(bitBlastConstant_108,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex35) ).

fof(bitBlastConstant_107,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex34) ).

fof(bitBlastConstant_106,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex33) ).

fof(bitBlastConstant_105,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex32) ).

fof(bitBlastConstant_104,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex31) ).

fof(bitBlastConstant_103,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex30) ).

fof(bitBlastConstant_102,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex29) ).

fof(bitBlastConstant_101,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex28) ).

fof(bitBlastConstant_100,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex27) ).

fof(bitBlastConstant_99,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex26) ).

fof(bitBlastConstant_98,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex25) ).

fof(bitBlastConstant_97,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex24) ).

fof(bitBlastConstant_96,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex23) ).

fof(bitBlastConstant_95,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex22) ).

fof(bitBlastConstant_94,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex21) ).

fof(bitBlastConstant_93,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex20) ).

fof(bitBlastConstant_92,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex19) ).

fof(bitBlastConstant_91,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex18) ).

fof(bitBlastConstant_90,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex17) ).

fof(bitBlastConstant_89,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex16) ).

fof(bitBlastConstant_88,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex15) ).

fof(bitBlastConstant_87,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex14) ).

fof(bitBlastConstant_86,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex13) ).

fof(bitBlastConstant_85,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex12) ).

fof(bitBlastConstant_84,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex11) ).

fof(bitBlastConstant_83,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex10) ).

fof(bitBlastConstant_82,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex9) ).

fof(bitBlastConstant_81,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex8) ).

fof(bitBlastConstant_80,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex7) ).

fof(bitBlastConstant_79,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex6) ).

fof(bitBlastConstant_78,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex5) ).

fof(bitBlastConstant_77,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex4) ).

fof(bitBlastConstant_76,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex3) ).

fof(bitBlastConstant_75,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex2) ).

fof(bitBlastConstant_74,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex1) ).

fof(bitBlastConstant_73,axiom,
    ~ b0000000000000000000000000000000000000000000000000000000000000000000(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_43,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v590(VarNext)
      <=> ( v591(VarNext)
          & v596(VarNext) ) ) ) ).

fof(addAssignment_152,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v596(VarNext)
      <=> v587(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_42,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v591(VarNext)
      <=> ( v593(VarNext)
          & v532(VarNext) ) ) ) ).

fof(writeUnaryOperator_38,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v593(VarNext)
      <=> v580(VarNext) ) ) ).

fof(memoryWriteDisabled_1,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v572_range_3_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ~ ( A = AssociatedAddressVar
                  & v576(VarNext) )
             => ! [B] :
                  ( range_66_0(B)
                 => ( v530_1__array(VarNext,A,B)
                  <=> v530_array(VarCurr,A,B) ) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange_1,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v572_range_3_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ( A = AssociatedAddressVar
                & v576(VarNext) )
             => ! [B] :
                  ( range_66_0(B)
                 => ( v530_1__array(VarNext,A,B)
                  <=> v537(VarNext,B) ) ) ) ) ) ).

fof(range_axiom_11,axiom,
    ! [B] :
      ( range_66_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B
        | bitIndex11 = B
        | bitIndex12 = B
        | bitIndex13 = B
        | bitIndex14 = B
        | bitIndex15 = B
        | bitIndex16 = B
        | bitIndex17 = B
        | bitIndex18 = B
        | bitIndex19 = B
        | bitIndex20 = B
        | bitIndex21 = B
        | bitIndex22 = B
        | bitIndex23 = B
        | bitIndex24 = B
        | bitIndex25 = B
        | bitIndex26 = B
        | bitIndex27 = B
        | bitIndex28 = B
        | bitIndex29 = B
        | bitIndex30 = B
        | bitIndex31 = B
        | bitIndex32 = B
        | bitIndex33 = B
        | bitIndex34 = B
        | bitIndex35 = B
        | bitIndex36 = B
        | bitIndex37 = B
        | bitIndex38 = B
        | bitIndex39 = B
        | bitIndex40 = B
        | bitIndex41 = B
        | bitIndex42 = B
        | bitIndex43 = B
        | bitIndex44 = B
        | bitIndex45 = B
        | bitIndex46 = B
        | bitIndex47 = B
        | bitIndex48 = B
        | bitIndex49 = B
        | bitIndex50 = B
        | bitIndex51 = B
        | bitIndex52 = B
        | bitIndex53 = B
        | bitIndex54 = B
        | bitIndex55 = B
        | bitIndex56 = B
        | bitIndex57 = B
        | bitIndex58 = B
        | bitIndex59 = B
        | bitIndex60 = B
        | bitIndex61 = B
        | bitIndex62 = B
        | bitIndex63 = B
        | bitIndex64 = B
        | bitIndex65 = B
        | bitIndex66 = B ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_41,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v576(VarNext)
      <=> ( v577(VarNext)
          & v585(VarNext) ) ) ) ).

fof(addAssignment_151,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v585(VarNext)
      <=> v583(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_40,axiom,
    ! [VarCurr] :
      ( v583(VarCurr)
    <=> ( v586(VarCurr)
        & v564(VarCurr) ) ) ).

fof(writeUnaryOperator_37,axiom,
    ! [VarCurr] :
      ( ~ v586(VarCurr)
    <=> v587(VarCurr) ) ).

fof(writeUnaryOperator_36,axiom,
    ! [VarCurr] :
      ( ~ v587(VarCurr)
    <=> v535(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_39,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v577(VarNext)
      <=> ( v578(VarNext)
          & v532(VarNext) ) ) ) ).

fof(writeUnaryOperator_35,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v578(VarNext)
      <=> v580(VarNext) ) ) ).

fof(addAssignment_150,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v580(VarNext)
      <=> v532(VarCurr) ) ) ).

fof(addAssignment_149,axiom,
    ! [VarCurr] :
      ( v564(VarCurr)
    <=> v566(VarCurr) ) ).

fof(addAssignment_148,axiom,
    ! [VarCurr] :
      ( v566(VarCurr)
    <=> v568(VarCurr) ) ).

fof(addAssignment_147,axiom,
    ! [VarCurr] :
      ( v568(VarCurr)
    <=> v570(VarCurr) ) ).

fof(addAssignment_146,axiom,
    ! [VarCurr,B] :
      ( range_10_0(B)
     => ( v537(VarCurr,B)
      <=> v557(VarCurr,B) ) ) ).

fof(addAssignment_145,axiom,
    ! [VarCurr] :
      ( ( v537(VarCurr,bitIndex26)
      <=> v551(VarCurr,bitIndex15) )
      & ( v537(VarCurr,bitIndex25)
      <=> v551(VarCurr,bitIndex14) )
      & ( v537(VarCurr,bitIndex24)
      <=> v551(VarCurr,bitIndex13) )
      & ( v537(VarCurr,bitIndex23)
      <=> v551(VarCurr,bitIndex12) )
      & ( v537(VarCurr,bitIndex22)
      <=> v551(VarCurr,bitIndex11) )
      & ( v537(VarCurr,bitIndex21)
      <=> v551(VarCurr,bitIndex10) )
      & ( v537(VarCurr,bitIndex20)
      <=> v551(VarCurr,bitIndex9) )
      & ( v537(VarCurr,bitIndex19)
      <=> v551(VarCurr,bitIndex8) )
      & ( v537(VarCurr,bitIndex18)
      <=> v551(VarCurr,bitIndex7) )
      & ( v537(VarCurr,bitIndex17)
      <=> v551(VarCurr,bitIndex6) )
      & ( v537(VarCurr,bitIndex16)
      <=> v551(VarCurr,bitIndex5) )
      & ( v537(VarCurr,bitIndex15)
      <=> v551(VarCurr,bitIndex4) )
      & ( v537(VarCurr,bitIndex14)
      <=> v551(VarCurr,bitIndex3) )
      & ( v537(VarCurr,bitIndex13)
      <=> v551(VarCurr,bitIndex2) )
      & ( v537(VarCurr,bitIndex12)
      <=> v551(VarCurr,bitIndex1) )
      & ( v537(VarCurr,bitIndex11)
      <=> v551(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_144,axiom,
    ! [VarCurr] :
      ( ( v537(VarCurr,bitIndex62)
      <=> v545(VarCurr,bitIndex35) )
      & ( v537(VarCurr,bitIndex61)
      <=> v545(VarCurr,bitIndex34) )
      & ( v537(VarCurr,bitIndex60)
      <=> v545(VarCurr,bitIndex33) )
      & ( v537(VarCurr,bitIndex59)
      <=> v545(VarCurr,bitIndex32) )
      & ( v537(VarCurr,bitIndex58)
      <=> v545(VarCurr,bitIndex31) )
      & ( v537(VarCurr,bitIndex57)
      <=> v545(VarCurr,bitIndex30) )
      & ( v537(VarCurr,bitIndex56)
      <=> v545(VarCurr,bitIndex29) )
      & ( v537(VarCurr,bitIndex55)
      <=> v545(VarCurr,bitIndex28) )
      & ( v537(VarCurr,bitIndex54)
      <=> v545(VarCurr,bitIndex27) )
      & ( v537(VarCurr,bitIndex53)
      <=> v545(VarCurr,bitIndex26) )
      & ( v537(VarCurr,bitIndex52)
      <=> v545(VarCurr,bitIndex25) )
      & ( v537(VarCurr,bitIndex51)
      <=> v545(VarCurr,bitIndex24) )
      & ( v537(VarCurr,bitIndex50)
      <=> v545(VarCurr,bitIndex23) )
      & ( v537(VarCurr,bitIndex49)
      <=> v545(VarCurr,bitIndex22) )
      & ( v537(VarCurr,bitIndex48)
      <=> v545(VarCurr,bitIndex21) )
      & ( v537(VarCurr,bitIndex47)
      <=> v545(VarCurr,bitIndex20) )
      & ( v537(VarCurr,bitIndex46)
      <=> v545(VarCurr,bitIndex19) )
      & ( v537(VarCurr,bitIndex45)
      <=> v545(VarCurr,bitIndex18) )
      & ( v537(VarCurr,bitIndex44)
      <=> v545(VarCurr,bitIndex17) )
      & ( v537(VarCurr,bitIndex43)
      <=> v545(VarCurr,bitIndex16) )
      & ( v537(VarCurr,bitIndex42)
      <=> v545(VarCurr,bitIndex15) )
      & ( v537(VarCurr,bitIndex41)
      <=> v545(VarCurr,bitIndex14) )
      & ( v537(VarCurr,bitIndex40)
      <=> v545(VarCurr,bitIndex13) )
      & ( v537(VarCurr,bitIndex39)
      <=> v545(VarCurr,bitIndex12) )
      & ( v537(VarCurr,bitIndex38)
      <=> v545(VarCurr,bitIndex11) )
      & ( v537(VarCurr,bitIndex37)
      <=> v545(VarCurr,bitIndex10) )
      & ( v537(VarCurr,bitIndex36)
      <=> v545(VarCurr,bitIndex9) )
      & ( v537(VarCurr,bitIndex35)
      <=> v545(VarCurr,bitIndex8) )
      & ( v537(VarCurr,bitIndex34)
      <=> v545(VarCurr,bitIndex7) )
      & ( v537(VarCurr,bitIndex33)
      <=> v545(VarCurr,bitIndex6) )
      & ( v537(VarCurr,bitIndex32)
      <=> v545(VarCurr,bitIndex5) )
      & ( v537(VarCurr,bitIndex31)
      <=> v545(VarCurr,bitIndex4) )
      & ( v537(VarCurr,bitIndex30)
      <=> v545(VarCurr,bitIndex3) )
      & ( v537(VarCurr,bitIndex29)
      <=> v545(VarCurr,bitIndex2) )
      & ( v537(VarCurr,bitIndex28)
      <=> v545(VarCurr,bitIndex1) )
      & ( v537(VarCurr,bitIndex27)
      <=> v545(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_143,axiom,
    ! [VarCurr] :
      ( ( v537(VarCurr,bitIndex66)
      <=> v539(VarCurr,bitIndex3) )
      & ( v537(VarCurr,bitIndex65)
      <=> v539(VarCurr,bitIndex2) )
      & ( v537(VarCurr,bitIndex64)
      <=> v539(VarCurr,bitIndex1) )
      & ( v537(VarCurr,bitIndex63)
      <=> v539(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_142,axiom,
    ! [VarCurr,B] :
      ( range_10_0(B)
     => ( v557(VarCurr,B)
      <=> v559(VarCurr,B) ) ) ).

fof(addAssignment_141,axiom,
    ! [VarCurr,B] :
      ( range_10_0(B)
     => ( v559(VarCurr,B)
      <=> v561(VarCurr,B) ) ) ).

fof(range_axiom_10,axiom,
    ! [B] :
      ( range_10_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B ) ) ).

fof(addAssignment_140,axiom,
    ! [VarCurr,B] :
      ( range_15_0(B)
     => ( v551(VarCurr,B)
      <=> v553(VarCurr,B) ) ) ).

fof(addAssignment_139,axiom,
    ! [VarCurr,B] :
      ( range_15_0(B)
     => ( v553(VarCurr,B)
      <=> v555(VarCurr,B) ) ) ).

fof(addAssignment_138,axiom,
    ! [VarCurr,B] :
      ( range_35_0(B)
     => ( v545(VarCurr,B)
      <=> v547(VarCurr,B) ) ) ).

fof(addAssignment_137,axiom,
    ! [VarCurr,B] :
      ( range_35_0(B)
     => ( v547(VarCurr,B)
      <=> v549(VarCurr,B) ) ) ).

fof(range_axiom_9,axiom,
    ! [B] :
      ( range_35_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B
        | bitIndex11 = B
        | bitIndex12 = B
        | bitIndex13 = B
        | bitIndex14 = B
        | bitIndex15 = B
        | bitIndex16 = B
        | bitIndex17 = B
        | bitIndex18 = B
        | bitIndex19 = B
        | bitIndex20 = B
        | bitIndex21 = B
        | bitIndex22 = B
        | bitIndex23 = B
        | bitIndex24 = B
        | bitIndex25 = B
        | bitIndex26 = B
        | bitIndex27 = B
        | bitIndex28 = B
        | bitIndex29 = B
        | bitIndex30 = B
        | bitIndex31 = B
        | bitIndex32 = B
        | bitIndex33 = B
        | bitIndex34 = B
        | bitIndex35 = B ) ) ).

fof(addAssignment_136,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v539(VarCurr,B)
      <=> v541(VarCurr,B) ) ) ).

fof(addAssignment_135,axiom,
    ! [VarCurr,B] :
      ( range_3_0(B)
     => ( v541(VarCurr,B)
      <=> v543(VarCurr,B) ) ) ).

fof(addAssignment_134,axiom,
    ! [VarCurr] :
      ( v535(VarCurr)
    <=> v104(VarCurr) ) ).

fof(addAssignment_133,axiom,
    ! [VarCurr] :
      ( v532(VarCurr)
    <=> v303(VarCurr) ) ).

fof(addAssignment_132,axiom,
    ! [VarCurr] :
      ( v510(VarCurr)
    <=> v512(VarCurr) ) ).

fof(addAssignment_131,axiom,
    ! [VarCurr] :
      ( v512(VarCurr)
    <=> v514(VarCurr) ) ).

fof(addAssignment_130,axiom,
    ! [VarCurr] :
      ( v514(VarCurr)
    <=> v291(VarCurr,bitIndex1) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_38,axiom,
    ! [VarCurr] :
      ( v496(VarCurr)
    <=> ( v504(VarCurr)
        & v506(VarCurr) ) ) ).

fof(writeUnaryOperator_34,axiom,
    ! [VarCurr] :
      ( ~ v506(VarCurr)
    <=> v498(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_37,axiom,
    ! [VarCurr] :
      ( v504(VarCurr)
    <=> ( v505(VarCurr)
        & v285(VarCurr) ) ) ).

fof(writeUnaryOperator_33,axiom,
    ! [VarCurr] :
      ( ~ v505(VarCurr)
    <=> v373(VarCurr) ) ).

fof(addAssignment_129,axiom,
    ! [VarCurr] :
      ( v498(VarCurr)
    <=> v500(VarCurr) ) ).

fof(addAssignment_128,axiom,
    ! [VarCurr] :
      ( v500(VarCurr)
    <=> v502(VarCurr,bitIndex0) ) ).

fof(addAssignment_127,axiom,
    ! [VarCurr] :
      ( v502(VarCurr,bitIndex0)
    <=> v490(VarCurr,bitIndex0) ) ).

fof(addAssignment_126,axiom,
    ! [VarCurr] :
      ( v490(VarCurr,bitIndex0)
    <=> v295(VarCurr,bitIndex0) ) ).

fof(addAssignment_125,axiom,
    ! [VarCurr] :
      ( v295(VarCurr,bitIndex0)
    <=> v297(VarCurr,bitIndex0) ) ).

fof(addAssignment_124,axiom,
    ! [VarCurr] :
      ( v297(VarCurr,bitIndex0)
    <=> v359(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_36,axiom,
    ! [VarCurr] :
      ( v371(VarCurr)
    <=> ( v494(VarCurr)
        & v480(VarCurr) ) ) ).

fof(writeUnaryOperator_32,axiom,
    ! [VarCurr] :
      ( ~ v494(VarCurr)
    <=> v373(VarCurr) ) ).

fof(addAssignment_123,axiom,
    ! [VarCurr] :
      ( v480(VarCurr)
    <=> v482(VarCurr) ) ).

fof(addAssignment_122,axiom,
    ! [VarCurr] :
      ( v482(VarCurr)
    <=> v484(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_35,axiom,
    ! [VarCurr] :
      ( v484(VarCurr)
    <=> ( v492(VarCurr)
        & v486(VarCurr) ) ) ).

fof(writeUnaryOperator_31,axiom,
    ! [VarCurr] :
      ( ~ v492(VarCurr)
    <=> v291(VarCurr,bitIndex1) ) ).

fof(addAssignment_121,axiom,
    ! [VarCurr] :
      ( v486(VarCurr)
    <=> v488(VarCurr) ) ).

fof(addAssignment_120,axiom,
    ! [VarCurr] :
      ( v488(VarCurr)
    <=> v490(VarCurr,bitIndex15) ) ).

fof(addAssignment_119,axiom,
    ! [VarCurr] :
      ( v490(VarCurr,bitIndex15)
    <=> v295(VarCurr,bitIndex15) ) ).

fof(addAssignment_118,axiom,
    ! [VarCurr] :
      ( v295(VarCurr,bitIndex15)
    <=> v297(VarCurr,bitIndex15) ) ).

fof(addAssignment_117,axiom,
    ! [VarCurr] :
      ( v297(VarCurr,bitIndex15)
    <=> v359(VarCurr,bitIndex15) ) ).

fof(addAssignment_116,axiom,
    ! [VarCurr] :
      ( v373(VarCurr)
    <=> v375(VarCurr) ) ).

fof(addAssignment_115,axiom,
    ! [VarCurr] :
      ( v375(VarCurr)
    <=> v377(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_12,axiom,
    ! [VarCurr] :
      ( v377(VarCurr)
    <=> ( ( v379(VarCurr,bitIndex4)
        <=> $false )
        & ( v379(VarCurr,bitIndex3)
        <=> $false )
        & ( v379(VarCurr,bitIndex2)
        <=> $false )
        & ( v379(VarCurr,bitIndex1)
        <=> $false )
        & ( v379(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addCaseBooleanConditionEqualRanges1_3,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v466(VarNext)
       => ! [B] :
            ( range_4_0(B)
           => ( v379(VarNext,B)
            <=> v379(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_3,axiom,
    ! [VarNext] :
      ( v466(VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v379(VarNext,B)
          <=> v474(VarNext,B) ) ) ) ).

fof(addAssignment_114,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_4_0(B)
         => ( v474(VarNext,B)
          <=> v472(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_4,axiom,
    ! [VarCurr] :
      ( ~ v475(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v472(VarCurr,B)
          <=> v382(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_4,axiom,
    ! [VarCurr] :
      ( v475(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v472(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_30,axiom,
    ! [VarCurr] :
      ( ~ v475(VarCurr)
    <=> v308(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_34,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v466(VarNext)
      <=> v467(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_33,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v467(VarNext)
      <=> ( v468(VarNext)
          & v301(VarNext) ) ) ) ).

fof(writeUnaryOperator_29,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v468(VarNext)
      <=> v341(VarNext) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges3_1,axiom,
    ! [VarCurr] :
      ( ( ~ v388(VarCurr)
        & ~ v390(VarCurr)
        & ~ v433(VarCurr) )
     => ! [B] :
          ( range_4_0(B)
         => ( v382(VarCurr,B)
          <=> v379(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_2,axiom,
    ! [VarCurr] :
      ( v433(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v382(VarCurr,B)
          <=> v435(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_2,axiom,
    ! [VarCurr] :
      ( v390(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v382(VarCurr,B)
          <=> v392(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_2,axiom,
    ! [VarCurr] :
      ( v388(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v382(VarCurr,B)
          <=> v379(VarCurr,B) ) ) ) ).

fof(addBitVectorEqualityBitBlasted_11,axiom,
    ! [VarCurr] :
      ( v462(VarCurr)
    <=> ( ( v463(VarCurr,bitIndex1)
        <=> $true )
        & ( v463(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_113,axiom,
    ! [VarCurr] :
      ( v463(VarCurr,bitIndex0)
    <=> v365(VarCurr) ) ).

fof(addAssignment_112,axiom,
    ! [VarCurr] :
      ( v463(VarCurr,bitIndex1)
    <=> v325(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_3,axiom,
    ! [VarCurr] :
      ( ~ v436(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v435(VarCurr,B)
          <=> v437(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_3,axiom,
    ! [VarCurr] :
      ( v436(VarCurr)
     => ! [B] :
          ( range_4_0(B)
         => ( v435(VarCurr,B)
          <=> b10000(B) ) ) ) ).

fof(addAssignment_111,axiom,
    ! [VarCurr] :
      ( v437(VarCurr,bitIndex0)
    <=> v459(VarCurr) ) ).

fof(addAssignment_110,axiom,
    ! [VarCurr] :
      ( v437(VarCurr,bitIndex1)
    <=> v457(VarCurr) ) ).

fof(addAssignment_109,axiom,
    ! [VarCurr] :
      ( v437(VarCurr,bitIndex2)
    <=> v452(VarCurr) ) ).

fof(addAssignment_108,axiom,
    ! [VarCurr] :
      ( v437(VarCurr,bitIndex3)
    <=> v447(VarCurr) ) ).

fof(addAssignment_107,axiom,
    ! [VarCurr] :
      ( v437(VarCurr,bitIndex4)
    <=> v439(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_32,axiom,
    ! [VarCurr] :
      ( v457(VarCurr)
    <=> ( v458(VarCurr)
        & v461(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_15,axiom,
    ! [VarCurr] :
      ( v461(VarCurr)
    <=> ( v379(VarCurr,bitIndex0)
        | v379(VarCurr,bitIndex1) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_31,axiom,
    ! [VarCurr] :
      ( v458(VarCurr)
    <=> ( v459(VarCurr)
        | v460(VarCurr) ) ) ).

fof(writeUnaryOperator_28,axiom,
    ! [VarCurr] :
      ( ~ v460(VarCurr)
    <=> v379(VarCurr,bitIndex1) ) ).

fof(writeUnaryOperator_27,axiom,
    ! [VarCurr] :
      ( ~ v459(VarCurr)
    <=> v379(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_30,axiom,
    ! [VarCurr] :
      ( v452(VarCurr)
    <=> ( v453(VarCurr)
        & v456(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_14,axiom,
    ! [VarCurr] :
      ( v456(VarCurr)
    <=> ( v444(VarCurr)
        | v379(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_29,axiom,
    ! [VarCurr] :
      ( v453(VarCurr)
    <=> ( v454(VarCurr)
        | v455(VarCurr) ) ) ).

fof(writeUnaryOperator_26,axiom,
    ! [VarCurr] :
      ( ~ v455(VarCurr)
    <=> v379(VarCurr,bitIndex2) ) ).

fof(writeUnaryOperator_25,axiom,
    ! [VarCurr] :
      ( ~ v454(VarCurr)
    <=> v444(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_28,axiom,
    ! [VarCurr] :
      ( v447(VarCurr)
    <=> ( v448(VarCurr)
        & v451(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_13,axiom,
    ! [VarCurr] :
      ( v451(VarCurr)
    <=> ( v443(VarCurr)
        | v379(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_27,axiom,
    ! [VarCurr] :
      ( v448(VarCurr)
    <=> ( v449(VarCurr)
        | v450(VarCurr) ) ) ).

fof(writeUnaryOperator_24,axiom,
    ! [VarCurr] :
      ( ~ v450(VarCurr)
    <=> v379(VarCurr,bitIndex3) ) ).

fof(writeUnaryOperator_23,axiom,
    ! [VarCurr] :
      ( ~ v449(VarCurr)
    <=> v443(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_26,axiom,
    ! [VarCurr] :
      ( v439(VarCurr)
    <=> ( v440(VarCurr)
        & v446(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_12,axiom,
    ! [VarCurr] :
      ( v446(VarCurr)
    <=> ( v442(VarCurr)
        | v379(VarCurr,bitIndex4) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_25,axiom,
    ! [VarCurr] :
      ( v440(VarCurr)
    <=> ( v441(VarCurr)
        | v445(VarCurr) ) ) ).

fof(writeUnaryOperator_22,axiom,
    ! [VarCurr] :
      ( ~ v445(VarCurr)
    <=> v379(VarCurr,bitIndex4) ) ).

fof(writeUnaryOperator_21,axiom,
    ! [VarCurr] :
      ( ~ v441(VarCurr)
    <=> v442(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_11,axiom,
    ! [VarCurr] :
      ( v442(VarCurr)
    <=> ( v443(VarCurr)
        & v379(VarCurr,bitIndex3) ) ) ).

fof(writeBinaryOperatorShiftedRanges_10,axiom,
    ! [VarCurr] :
      ( v443(VarCurr)
    <=> ( v444(VarCurr)
        & v379(VarCurr,bitIndex2) ) ) ).

fof(writeBinaryOperatorShiftedRanges_9,axiom,
    ! [VarCurr] :
      ( v444(VarCurr)
    <=> ( v379(VarCurr,bitIndex0)
        & v379(VarCurr,bitIndex1) ) ) ).

fof(addBitVectorEqualityBitBlasted_10,axiom,
    ! [VarCurr] :
      ( v436(VarCurr)
    <=> ( ( v379(VarCurr,bitIndex4)
        <=> $true )
        & ( v379(VarCurr,bitIndex3)
        <=> $false )
        & ( v379(VarCurr,bitIndex2)
        <=> $false )
        & ( v379(VarCurr,bitIndex1)
        <=> $false )
        & ( v379(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_72,axiom,
    b10000(bitIndex4) ).

fof(bitBlastConstant_71,axiom,
    ~ b10000(bitIndex3) ).

fof(bitBlastConstant_70,axiom,
    ~ b10000(bitIndex2) ).

fof(bitBlastConstant_69,axiom,
    ~ b10000(bitIndex1) ).

fof(bitBlastConstant_68,axiom,
    ~ b10000(bitIndex0) ).

fof(addBitVectorEqualityBitBlasted_9,axiom,
    ! [VarCurr] :
      ( v433(VarCurr)
    <=> ( ( v434(VarCurr,bitIndex1)
        <=> $true )
        & ( v434(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_106,axiom,
    ! [VarCurr] :
      ( v434(VarCurr,bitIndex0)
    <=> v365(VarCurr) ) ).

fof(addAssignment_105,axiom,
    ! [VarCurr] :
      ( v434(VarCurr,bitIndex1)
    <=> v325(VarCurr) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_2,axiom,
    ! [VarCurr] :
      ( ~ v393(VarCurr)
     => ! [B] :
          ( range_31_0(B)
         => ( v392(VarCurr,B)
          <=> v394(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_2,axiom,
    ! [VarCurr] :
      ( v393(VarCurr)
     => ! [B] :
          ( range_31_0(B)
         => ( v392(VarCurr,B)
          <=> $false ) ) ) ).

fof(range_axiom_8,axiom,
    ! [B] :
      ( range_31_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B
        | bitIndex11 = B
        | bitIndex12 = B
        | bitIndex13 = B
        | bitIndex14 = B
        | bitIndex15 = B
        | bitIndex16 = B
        | bitIndex17 = B
        | bitIndex18 = B
        | bitIndex19 = B
        | bitIndex20 = B
        | bitIndex21 = B
        | bitIndex22 = B
        | bitIndex23 = B
        | bitIndex24 = B
        | bitIndex25 = B
        | bitIndex26 = B
        | bitIndex27 = B
        | bitIndex28 = B
        | bitIndex29 = B
        | bitIndex30 = B
        | bitIndex31 = B ) ) ).

fof(bitBlastConstant_67,axiom,
    ~ b00000000000000000000000000000000(bitIndex31) ).

fof(bitBlastConstant_66,axiom,
    ~ b00000000000000000000000000000000(bitIndex30) ).

fof(bitBlastConstant_65,axiom,
    ~ b00000000000000000000000000000000(bitIndex29) ).

fof(bitBlastConstant_64,axiom,
    ~ b00000000000000000000000000000000(bitIndex28) ).

fof(bitBlastConstant_63,axiom,
    ~ b00000000000000000000000000000000(bitIndex27) ).

fof(bitBlastConstant_62,axiom,
    ~ b00000000000000000000000000000000(bitIndex26) ).

fof(bitBlastConstant_61,axiom,
    ~ b00000000000000000000000000000000(bitIndex25) ).

fof(bitBlastConstant_60,axiom,
    ~ b00000000000000000000000000000000(bitIndex24) ).

fof(bitBlastConstant_59,axiom,
    ~ b00000000000000000000000000000000(bitIndex23) ).

fof(bitBlastConstant_58,axiom,
    ~ b00000000000000000000000000000000(bitIndex22) ).

fof(bitBlastConstant_57,axiom,
    ~ b00000000000000000000000000000000(bitIndex21) ).

fof(bitBlastConstant_56,axiom,
    ~ b00000000000000000000000000000000(bitIndex20) ).

fof(bitBlastConstant_55,axiom,
    ~ b00000000000000000000000000000000(bitIndex19) ).

fof(bitBlastConstant_54,axiom,
    ~ b00000000000000000000000000000000(bitIndex18) ).

fof(bitBlastConstant_53,axiom,
    ~ b00000000000000000000000000000000(bitIndex17) ).

fof(bitBlastConstant_52,axiom,
    ~ b00000000000000000000000000000000(bitIndex16) ).

fof(bitBlastConstant_51,axiom,
    ~ b00000000000000000000000000000000(bitIndex15) ).

fof(bitBlastConstant_50,axiom,
    ~ b00000000000000000000000000000000(bitIndex14) ).

fof(bitBlastConstant_49,axiom,
    ~ b00000000000000000000000000000000(bitIndex13) ).

fof(bitBlastConstant_48,axiom,
    ~ b00000000000000000000000000000000(bitIndex12) ).

fof(bitBlastConstant_47,axiom,
    ~ b00000000000000000000000000000000(bitIndex11) ).

fof(bitBlastConstant_46,axiom,
    ~ b00000000000000000000000000000000(bitIndex10) ).

fof(bitBlastConstant_45,axiom,
    ~ b00000000000000000000000000000000(bitIndex9) ).

fof(bitBlastConstant_44,axiom,
    ~ b00000000000000000000000000000000(bitIndex8) ).

fof(bitBlastConstant_43,axiom,
    ~ b00000000000000000000000000000000(bitIndex7) ).

fof(bitBlastConstant_42,axiom,
    ~ b00000000000000000000000000000000(bitIndex6) ).

fof(bitBlastConstant_41,axiom,
    ~ b00000000000000000000000000000000(bitIndex5) ).

fof(bitBlastConstant_40,axiom,
    ~ b00000000000000000000000000000000(bitIndex4) ).

fof(bitBlastConstant_39,axiom,
    ~ b00000000000000000000000000000000(bitIndex3) ).

fof(bitBlastConstant_38,axiom,
    ~ b00000000000000000000000000000000(bitIndex2) ).

fof(bitBlastConstant_37,axiom,
    ~ b00000000000000000000000000000000(bitIndex1) ).

fof(bitBlastConstant_36,axiom,
    ~ b00000000000000000000000000000000(bitIndex0) ).

fof(addSignExtensionConstraint_25,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex6)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_24,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex7)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_23,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex8)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_22,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex9)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_21,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex10)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_20,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex11)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_19,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex12)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_18,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex13)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_17,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex14)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_16,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex15)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_15,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex16)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_14,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex17)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_13,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex18)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_12,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex19)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_11,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex20)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_10,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex21)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_9,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex22)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_8,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex23)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_7,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex24)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_6,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex25)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_5,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex26)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_4,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex27)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_3,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex28)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_2,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex29)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint_1,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex30)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addSignExtensionConstraint,axiom,
    ! [VarCurr] :
      ( v394(VarCurr,bitIndex31)
    <=> v395(VarCurr,bitIndex5) ) ).

fof(addAssignment_104,axiom,
    ! [VarCurr,B] :
      ( range_5_0(B)
     => ( v394(VarCurr,B)
      <=> v395(VarCurr,B) ) ) ).

fof(range_axiom_7,axiom,
    ! [B] :
      ( range_5_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B ) ) ).

fof(addAssignment_103,axiom,
    ! [VarCurr] :
      ( v395(VarCurr,bitIndex0)
    <=> v430(VarCurr) ) ).

fof(addAssignment_102,axiom,
    ! [VarCurr] :
      ( v395(VarCurr,bitIndex1)
    <=> v428(VarCurr) ) ).

fof(addAssignment_101,axiom,
    ! [VarCurr] :
      ( v395(VarCurr,bitIndex2)
    <=> v424(VarCurr) ) ).

fof(addAssignment_100,axiom,
    ! [VarCurr] :
      ( v395(VarCurr,bitIndex3)
    <=> v420(VarCurr) ) ).

fof(addAssignment_99,axiom,
    ! [VarCurr] :
      ( v395(VarCurr,bitIndex4)
    <=> v416(VarCurr) ) ).

fof(addAssignment_98,axiom,
    ! [VarCurr] :
      ( v395(VarCurr,bitIndex5)
    <=> v397(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_24,axiom,
    ! [VarCurr] :
      ( v428(VarCurr)
    <=> ( v429(VarCurr)
        & v431(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_23,axiom,
    ! [VarCurr] :
      ( v431(VarCurr)
    <=> ( v401(VarCurr,bitIndex0)
        | v410(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_8,axiom,
    ! [VarCurr] :
      ( v429(VarCurr)
    <=> ( v430(VarCurr)
        | v401(VarCurr,bitIndex1) ) ) ).

fof(writeUnaryOperator_20,axiom,
    ! [VarCurr] :
      ( ~ v430(VarCurr)
    <=> v401(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_22,axiom,
    ! [VarCurr] :
      ( v424(VarCurr)
    <=> ( v425(VarCurr)
        & v427(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_21,axiom,
    ! [VarCurr] :
      ( v427(VarCurr)
    <=> ( v408(VarCurr)
        | v411(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_7,axiom,
    ! [VarCurr] :
      ( v425(VarCurr)
    <=> ( v426(VarCurr)
        | v401(VarCurr,bitIndex2) ) ) ).

fof(writeUnaryOperator_19,axiom,
    ! [VarCurr] :
      ( ~ v426(VarCurr)
    <=> v408(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_20,axiom,
    ! [VarCurr] :
      ( v420(VarCurr)
    <=> ( v421(VarCurr)
        & v423(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_19,axiom,
    ! [VarCurr] :
      ( v423(VarCurr)
    <=> ( v406(VarCurr)
        | v412(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_6,axiom,
    ! [VarCurr] :
      ( v421(VarCurr)
    <=> ( v422(VarCurr)
        | v401(VarCurr,bitIndex3) ) ) ).

fof(writeUnaryOperator_18,axiom,
    ! [VarCurr] :
      ( ~ v422(VarCurr)
    <=> v406(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_18,axiom,
    ! [VarCurr] :
      ( v416(VarCurr)
    <=> ( v417(VarCurr)
        & v419(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_17,axiom,
    ! [VarCurr] :
      ( v419(VarCurr)
    <=> ( v404(VarCurr)
        | v413(VarCurr) ) ) ).

fof(writeBinaryOperatorShiftedRanges_5,axiom,
    ! [VarCurr] :
      ( v417(VarCurr)
    <=> ( v418(VarCurr)
        | v401(VarCurr,bitIndex4) ) ) ).

fof(writeUnaryOperator_17,axiom,
    ! [VarCurr] :
      ( ~ v418(VarCurr)
    <=> v404(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_16,axiom,
    ! [VarCurr] :
      ( v397(VarCurr)
    <=> ( v398(VarCurr)
        & v414(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_15,axiom,
    ! [VarCurr] :
      ( v414(VarCurr)
    <=> ( v400(VarCurr)
        | v415(VarCurr) ) ) ).

fof(writeUnaryOperator_16,axiom,
    ! [VarCurr] :
      ( ~ v415(VarCurr)
    <=> v401(VarCurr,bitIndex5) ) ).

fof(writeBinaryOperatorShiftedRanges_4,axiom,
    ! [VarCurr] :
      ( v398(VarCurr)
    <=> ( v399(VarCurr)
        | v401(VarCurr,bitIndex5) ) ) ).

fof(writeUnaryOperator_15,axiom,
    ! [VarCurr] :
      ( ~ v399(VarCurr)
    <=> v400(VarCurr) ) ).

fof(writeBinaryOperatorShiftedRanges_3,axiom,
    ! [VarCurr] :
      ( v400(VarCurr)
    <=> ( v401(VarCurr,bitIndex4)
        | v403(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_14,axiom,
    ! [VarCurr] :
      ( v403(VarCurr)
    <=> ( v404(VarCurr)
        & v413(VarCurr) ) ) ).

fof(writeUnaryOperator_14,axiom,
    ! [VarCurr] :
      ( ~ v413(VarCurr)
    <=> v401(VarCurr,bitIndex4) ) ).

fof(writeBinaryOperatorShiftedRanges_2,axiom,
    ! [VarCurr] :
      ( v404(VarCurr)
    <=> ( v401(VarCurr,bitIndex3)
        | v405(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_13,axiom,
    ! [VarCurr] :
      ( v405(VarCurr)
    <=> ( v406(VarCurr)
        & v412(VarCurr) ) ) ).

fof(writeUnaryOperator_13,axiom,
    ! [VarCurr] :
      ( ~ v412(VarCurr)
    <=> v401(VarCurr,bitIndex3) ) ).

fof(writeBinaryOperatorShiftedRanges_1,axiom,
    ! [VarCurr] :
      ( v406(VarCurr)
    <=> ( v401(VarCurr,bitIndex2)
        | v407(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_12,axiom,
    ! [VarCurr] :
      ( v407(VarCurr)
    <=> ( v408(VarCurr)
        & v411(VarCurr) ) ) ).

fof(writeUnaryOperator_12,axiom,
    ! [VarCurr] :
      ( ~ v411(VarCurr)
    <=> v401(VarCurr,bitIndex2) ) ).

fof(writeBinaryOperatorShiftedRanges,axiom,
    ! [VarCurr] :
      ( v408(VarCurr)
    <=> ( v401(VarCurr,bitIndex1)
        | v409(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_11,axiom,
    ! [VarCurr] :
      ( v409(VarCurr)
    <=> ( v401(VarCurr,bitIndex0)
        & v410(VarCurr) ) ) ).

fof(writeUnaryOperator_11,axiom,
    ! [VarCurr] :
      ( ~ v410(VarCurr)
    <=> v401(VarCurr,bitIndex1) ) ).

fof(addZeroExtensionConstraint,axiom,
    ! [VarCurr] : ~ v401(VarCurr,bitIndex5) ).

fof(addAssignment_97,axiom,
    ! [VarCurr,B] :
      ( range_4_0(B)
     => ( v401(VarCurr,B)
      <=> v379(VarCurr,B) ) ) ).

fof(range_axiom_6,axiom,
    ! [B] :
      ( range_4_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B ) ) ).

fof(addBitVectorEqualityBitBlasted_8,axiom,
    ! [VarCurr] :
      ( v393(VarCurr)
    <=> ( ( v379(VarCurr,bitIndex4)
        <=> $false )
        & ( v379(VarCurr,bitIndex3)
        <=> $false )
        & ( v379(VarCurr,bitIndex2)
        <=> $false )
        & ( v379(VarCurr,bitIndex1)
        <=> $false )
        & ( v379(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_35,axiom,
    ~ b00000(bitIndex4) ).

fof(bitBlastConstant_34,axiom,
    ~ b00000(bitIndex3) ).

fof(bitBlastConstant_33,axiom,
    ~ b00000(bitIndex2) ).

fof(bitBlastConstant_32,axiom,
    ~ b00000(bitIndex1) ).

fof(bitBlastConstant_31,axiom,
    ~ b00000(bitIndex0) ).

fof(addBitVectorEqualityBitBlasted_7,axiom,
    ! [VarCurr] :
      ( v390(VarCurr)
    <=> ( ( v391(VarCurr,bitIndex1)
        <=> $false )
        & ( v391(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_96,axiom,
    ! [VarCurr] :
      ( v391(VarCurr,bitIndex0)
    <=> v365(VarCurr) ) ).

fof(addAssignment_95,axiom,
    ! [VarCurr] :
      ( v391(VarCurr,bitIndex1)
    <=> v325(VarCurr) ) ).

fof(addBitVectorEqualityBitBlasted_6,axiom,
    ! [VarCurr] :
      ( v388(VarCurr)
    <=> ( ( v389(VarCurr,bitIndex1)
        <=> $false )
        & ( v389(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_94,axiom,
    ! [VarCurr] :
      ( v389(VarCurr,bitIndex0)
    <=> v365(VarCurr) ) ).

fof(addAssignment_93,axiom,
    ! [VarCurr] :
      ( v389(VarCurr,bitIndex1)
    <=> v325(VarCurr) ) ).

fof(memoryReadIntoBuffer,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v361_range_3_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( address(A)
             => ! [B] :
                  ( A = AssociatedAddressVar
                 => ( range_17_0(B)
                   => ( v359(VarNext,B)
                    <=> v299_array(VarNext,A,B) ) ) ) ) ) ) ).

fof(memoryConstantWriteDisabled,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ~ ( $true
              & v351(VarNext) )
         => ! [B] :
              ( range_17_0(B)
             => ( v299_array(VarNext,A,B)
              <=> v299_1__array(VarNext,A,B) ) ) ) ) ).

fof(memoryConstantWriteEnabledInsideRange,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [A] :
          ( ( $true
            & v351(VarNext) )
         => ! [B] :
              ( range_17_0(B)
             => ( v299_array(VarNext,A,B)
              <=> b000000000000000000(B) ) ) ) ) ).

fof(bitBlastConstant_30,axiom,
    ~ b000000000000000000(bitIndex17) ).

fof(bitBlastConstant_29,axiom,
    ~ b000000000000000000(bitIndex16) ).

fof(bitBlastConstant_28,axiom,
    ~ b000000000000000000(bitIndex15) ).

fof(bitBlastConstant_27,axiom,
    ~ b000000000000000000(bitIndex14) ).

fof(bitBlastConstant_26,axiom,
    ~ b000000000000000000(bitIndex13) ).

fof(bitBlastConstant_25,axiom,
    ~ b000000000000000000(bitIndex12) ).

fof(bitBlastConstant_24,axiom,
    ~ b000000000000000000(bitIndex11) ).

fof(bitBlastConstant_23,axiom,
    ~ b000000000000000000(bitIndex10) ).

fof(bitBlastConstant_22,axiom,
    ~ b000000000000000000(bitIndex9) ).

fof(bitBlastConstant_21,axiom,
    ~ b000000000000000000(bitIndex8) ).

fof(bitBlastConstant_20,axiom,
    ~ b000000000000000000(bitIndex7) ).

fof(bitBlastConstant_19,axiom,
    ~ b000000000000000000(bitIndex6) ).

fof(bitBlastConstant_18,axiom,
    ~ b000000000000000000(bitIndex5) ).

fof(bitBlastConstant_17,axiom,
    ~ b000000000000000000(bitIndex4) ).

fof(bitBlastConstant_16,axiom,
    ~ b000000000000000000(bitIndex3) ).

fof(bitBlastConstant_15,axiom,
    ~ b000000000000000000(bitIndex2) ).

fof(bitBlastConstant_14,axiom,
    ~ b000000000000000000(bitIndex1) ).

fof(bitBlastConstant_13,axiom,
    ~ b000000000000000000(bitIndex0) ).

fof(writeBinaryOperatorEqualRangesSingleBits_10,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v351(VarNext)
      <=> ( v352(VarNext)
          & v357(VarNext) ) ) ) ).

fof(addAssignment_92,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v357(VarNext)
      <=> v348(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_9,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v352(VarNext)
      <=> ( v354(VarNext)
          & v301(VarNext) ) ) ) ).

fof(writeUnaryOperator_10,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v354(VarNext)
      <=> v341(VarNext) ) ) ).

fof(memoryWriteDisabled,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v333_range_3_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ~ ( A = AssociatedAddressVar
                  & v337(VarNext) )
             => ! [B] :
                  ( range_17_0(B)
                 => ( v299_1__array(VarNext,A,B)
                  <=> v299_array(VarCurr,A,B) ) ) ) ) ) ).

fof(memoryWriteEnabledInsideRange,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [AssociatedAddressVar] :
          ( v333_range_3_to_0_address_association(VarNext,AssociatedAddressVar)
         => ! [A] :
              ( ( A = AssociatedAddressVar
                & v337(VarNext) )
             => ! [B] :
                  ( range_17_0(B)
                 => ( v299_1__array(VarNext,A,B)
                  <=> v310(VarNext,B) ) ) ) ) ) ).

fof(range_axiom_5,axiom,
    ! [B] :
      ( range_17_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B
        | bitIndex11 = B
        | bitIndex12 = B
        | bitIndex13 = B
        | bitIndex14 = B
        | bitIndex15 = B
        | bitIndex16 = B
        | bitIndex17 = B ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_8,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v337(VarNext)
      <=> ( v338(VarNext)
          & v346(VarNext) ) ) ) ).

fof(addAssignment_91,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v346(VarNext)
      <=> v344(VarCurr) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_7,axiom,
    ! [VarCurr] :
      ( v344(VarCurr)
    <=> ( v347(VarCurr)
        & v325(VarCurr) ) ) ).

fof(writeUnaryOperator_9,axiom,
    ! [VarCurr] :
      ( ~ v347(VarCurr)
    <=> v348(VarCurr) ) ).

fof(writeUnaryOperator_8,axiom,
    ! [VarCurr] :
      ( ~ v348(VarCurr)
    <=> v308(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_6,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v338(VarNext)
      <=> ( v339(VarNext)
          & v301(VarNext) ) ) ) ).

fof(writeUnaryOperator_7,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v339(VarNext)
      <=> v341(VarNext) ) ) ).

fof(addAssignment_90,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v341(VarNext)
      <=> v301(VarCurr) ) ) ).

fof(addAssignment_89,axiom,
    ! [VarCurr] :
      ( v325(VarCurr)
    <=> v327(VarCurr) ) ).

fof(addAssignment_88,axiom,
    ! [VarCurr] :
      ( v327(VarCurr)
    <=> v329(VarCurr) ) ).

fof(addAssignment_87,axiom,
    ! [VarCurr] :
      ( v329(VarCurr)
    <=> v331(VarCurr) ) ).

fof(addAssignment_86,axiom,
    ! [VarCurr,B] :
      ( range_15_0(B)
     => ( v310(VarCurr,B)
      <=> v318(VarCurr,B) ) ) ).

fof(addAssignment_85,axiom,
    ! [VarCurr] :
      ( ( v310(VarCurr,bitIndex17)
      <=> v312(VarCurr,bitIndex1) )
      & ( v310(VarCurr,bitIndex16)
      <=> v312(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_84,axiom,
    ! [VarCurr,B] :
      ( range_15_0(B)
     => ( v318(VarCurr,B)
      <=> v320(VarCurr,B) ) ) ).

fof(addAssignment_83,axiom,
    ! [VarCurr,B] :
      ( range_15_0(B)
     => ( v320(VarCurr,B)
      <=> v322(VarCurr,B) ) ) ).

fof(range_axiom_4,axiom,
    ! [B] :
      ( range_15_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B
        | bitIndex4 = B
        | bitIndex5 = B
        | bitIndex6 = B
        | bitIndex7 = B
        | bitIndex8 = B
        | bitIndex9 = B
        | bitIndex10 = B
        | bitIndex11 = B
        | bitIndex12 = B
        | bitIndex13 = B
        | bitIndex14 = B
        | bitIndex15 = B ) ) ).

fof(addAssignment_82,axiom,
    ! [VarCurr,B] :
      ( range_1_0(B)
     => ( v312(VarCurr,B)
      <=> v314(VarCurr,B) ) ) ).

fof(addAssignment_81,axiom,
    ! [VarCurr,B] :
      ( range_1_0(B)
     => ( v314(VarCurr,B)
      <=> v316(VarCurr,B) ) ) ).

fof(addAssignment_80,axiom,
    ! [VarCurr] :
      ( v308(VarCurr)
    <=> v104(VarCurr) ) ).

fof(addAssignment_79,axiom,
    ! [VarCurr] :
      ( v301(VarCurr)
    <=> v303(VarCurr) ) ).

fof(addAssignment_78,axiom,
    ! [VarCurr] :
      ( v303(VarCurr)
    <=> v305(VarCurr) ) ).

fof(addAssignment_77,axiom,
    ! [VarCurr] :
      ( v305(VarCurr)
    <=> v1(VarCurr) ) ).

fof(addAssignment_76,axiom,
    ! [VarCurr] :
      ( v279(VarCurr)
    <=> v281(VarCurr) ) ).

fof(addAssignment_75,axiom,
    ! [VarCurr] :
      ( v281(VarCurr)
    <=> v212(VarCurr,bitIndex2) ) ).

fof(addAssignment_74,axiom,
    ! [VarCurr] :
      ( v212(VarCurr,bitIndex2)
    <=> v274(VarCurr,bitIndex2) ) ).

fof(addAssignment_73,axiom,
    ! [VarCurr] :
      ( v268(VarCurr,bitIndex2)
    <=> v272(VarCurr,bitIndex2) ) ).

fof(addAssignment_72,axiom,
    ! [VarCurr] :
      ( v270(VarCurr,bitIndex2)
    <=> v271(VarCurr,bitIndex1) ) ).

fof(addAssignment_71,axiom,
    ! [VarCurr] :
      ( v261(VarCurr,bitIndex2)
    <=> v265(VarCurr,bitIndex2) ) ).

fof(addAssignment_70,axiom,
    ! [VarCurr] :
      ( v263(VarCurr,bitIndex2)
    <=> v264(VarCurr,bitIndex1) ) ).

fof(addAssignment_69,axiom,
    ! [VarCurr] :
      ( v257(VarCurr)
    <=> v259(VarCurr) ) ).

fof(addAssignment_68,axiom,
    ! [VarCurr] :
      ( v259(VarCurr)
    <=> v212(VarCurr,bitIndex1) ) ).

fof(addAssignment_67,axiom,
    ! [VarCurr] :
      ( v212(VarCurr,bitIndex1)
    <=> v274(VarCurr,bitIndex1) ) ).

fof(writeBinaryOperatorEqualRangesMultipleBits_5,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v274(VarCurr,B)
      <=> ( v275(VarCurr,B)
          | v268(VarCurr,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesMultipleBits_4,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v275(VarCurr,B)
      <=> ( v276(VarCurr,B)
          & v261(VarCurr,B) ) ) ) ).

fof(addAssignment_66,axiom,
    ! [VarCurr] :
      ( v276(VarCurr,bitIndex0)
    <=> v277(VarCurr) ) ).

fof(addAssignment_65,axiom,
    ! [VarCurr] :
      ( v276(VarCurr,bitIndex1)
    <=> v277(VarCurr) ) ).

fof(addAssignment_64,axiom,
    ! [VarCurr] :
      ( v276(VarCurr,bitIndex2)
    <=> v277(VarCurr) ) ).

fof(addAssignment_63,axiom,
    ! [VarCurr] :
      ( v277(VarCurr)
    <=> v214(VarCurr) ) ).

fof(addAssignment_62,axiom,
    ! [VarCurr] :
      ( v268(VarCurr,bitIndex1)
    <=> v272(VarCurr,bitIndex1) ) ).

fof(writeBinaryOperatorEqualRangesMultipleBits_3,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v272(VarCurr,B)
      <=> ( v216(VarCurr,B)
          & v273(VarCurr,B) ) ) ) ).

fof(writeUnaryOperator_6,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v273(VarCurr,B)
      <=> ~ v270(VarCurr,B) ) ) ).

fof(addAssignment_61,axiom,
    ! [VarCurr] :
      ( v270(VarCurr,bitIndex1)
    <=> v271(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesMultipleBits_2,axiom,
    ! [VarCurr,B] :
      ( range_1_0(B)
     => ( v271(VarCurr,B)
      <=> ( v270(VarCurr,B)
          | v216(VarCurr,B) ) ) ) ).

fof(addAssignment_60,axiom,
    ! [VarCurr] :
      ( v270(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_59,axiom,
    ! [VarCurr] :
      ( v261(VarCurr,bitIndex1)
    <=> v265(VarCurr,bitIndex1) ) ).

fof(writeBinaryOperatorEqualRangesMultipleBits_1,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v265(VarCurr,B)
      <=> ( v218(VarCurr,B)
          & v266(VarCurr,B) ) ) ) ).

fof(writeUnaryOperator_5,axiom,
    ! [VarCurr,B] :
      ( range_2_0(B)
     => ( v266(VarCurr,B)
      <=> ~ v263(VarCurr,B) ) ) ).

fof(range_axiom_3,axiom,
    ! [B] :
      ( range_2_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B ) ) ).

fof(addAssignment_58,axiom,
    ! [VarCurr] :
      ( v263(VarCurr,bitIndex1)
    <=> v264(VarCurr,bitIndex0) ) ).

fof(writeBinaryOperatorEqualRangesMultipleBits,axiom,
    ! [VarCurr,B] :
      ( range_1_0(B)
     => ( v264(VarCurr,B)
      <=> ( v263(VarCurr,B)
          | v218(VarCurr,B) ) ) ) ).

fof(addAssignment_57,axiom,
    ! [VarCurr] :
      ( v263(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_56,axiom,
    ! [VarCurr] :
      ( v236(VarCurr)
    <=> v238(VarCurr) ) ).

fof(addAssignment_55,axiom,
    ! [VarCurr] :
      ( v238(VarCurr)
    <=> v240(VarCurr) ) ).

fof(addAssignment_54,axiom,
    ! [VarCurr] :
      ( v240(VarCurr)
    <=> v242(VarCurr) ) ).

fof(addAssignment_53,axiom,
    ! [VarCurr] :
      ( v242(VarCurr)
    <=> v244(VarCurr) ) ).

fof(addAssignment_52,axiom,
    ! [VarCurr] :
      ( v232(VarCurr)
    <=> v104(VarCurr) ) ).

fof(addAssignment_51,axiom,
    ! [VarCurr] :
      ( v112(VarCurr)
    <=> v114(VarCurr) ) ).

fof(addAssignment_50,axiom,
    ! [VarCurr] :
      ( v114(VarCurr)
    <=> v116(VarCurr) ) ).

fof(addAssignment_49,axiom,
    ! [VarCurr] :
      ( v116(VarCurr)
    <=> v118(VarCurr) ) ).

fof(addAssignment_48,axiom,
    ! [VarCurr] :
      ( v118(VarCurr)
    <=> v120(VarCurr) ) ).

fof(addAssignment_47,axiom,
    ! [VarCurr] :
      ( v120(VarCurr)
    <=> v122(VarCurr) ) ).

fof(addAssignment_46,axiom,
    ! [VarCurr] :
      ( v122(VarCurr)
    <=> v124(VarCurr) ) ).

fof(addAssignment_45,axiom,
    ! [VarCurr] :
      ( v124(VarCurr)
    <=> v126(VarCurr) ) ).

fof(addAssignment_44,axiom,
    ! [VarCurr] :
      ( v126(VarCurr)
    <=> v128(VarCurr) ) ).

fof(addAssignment_43,axiom,
    ! [VarCurr] :
      ( v128(VarCurr)
    <=> v130(VarCurr,bitIndex2) ) ).

fof(addAssignment_42,axiom,
    ! [VarNext] :
      ( v130(VarNext,bitIndex2)
    <=> v200(VarNext,bitIndex2) ) ).

fof(addCaseBooleanConditionEqualRanges1_2,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v201(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v200(VarNext,B)
            <=> v130(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_2,axiom,
    ! [VarNext] :
      ( v201(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v200(VarNext,B)
          <=> v185(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_5,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v201(VarNext)
      <=> v202(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_4,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v202(VarNext)
      <=> ( v204(VarNext)
          & v166(VarNext) ) ) ) ).

fof(writeUnaryOperator_4,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v204(VarNext)
      <=> v179(VarNext) ) ) ).

fof(addAssignment_41,axiom,
    ! [VarCurr] :
      ( v133(VarCurr,bitIndex2)
    <=> v149(VarCurr,bitIndex2) ) ).

fof(addAssignment_40,axiom,
    ! [VarCurr] :
      ( v147(VarCurr,bitIndex2)
    <=> v189(VarCurr,bitIndex2) ) ).

fof(addAssignment_39,axiom,
    ! [VarNext] :
      ( v130(VarNext,bitIndex1)
    <=> v192(VarNext,bitIndex1) ) ).

fof(addCaseBooleanConditionEqualRanges1_1,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v193(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v192(VarNext,B)
            <=> v130(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0_1,axiom,
    ! [VarNext] :
      ( v193(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v192(VarNext,B)
          <=> v185(VarNext,B) ) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_3,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v193(VarNext)
      <=> v194(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_2,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v194(VarNext)
      <=> ( v196(VarNext)
          & v166(VarNext) ) ) ) ).

fof(writeUnaryOperator_3,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v196(VarNext)
      <=> v179(VarNext) ) ) ).

fof(addAssignment_38,axiom,
    ! [VarCurr] :
      ( v133(VarCurr,bitIndex1)
    <=> v149(VarCurr,bitIndex1) ) ).

fof(addAssignment_37,axiom,
    ! [VarCurr] :
      ( v147(VarCurr,bitIndex1)
    <=> v189(VarCurr,bitIndex1) ) ).

fof(addAssignment_36,axiom,
    ! [VarCurr] :
      ( v189(VarCurr,bitIndex0)
    <=> $false ) ).

fof(addAssignment_35,axiom,
    ! [VarCurr] :
      ( ( v189(VarCurr,bitIndex3)
      <=> v130(VarCurr,bitIndex2) )
      & ( v189(VarCurr,bitIndex2)
      <=> v130(VarCurr,bitIndex1) )
      & ( v189(VarCurr,bitIndex1)
      <=> v130(VarCurr,bitIndex0) ) ) ).

fof(addAssignment_34,axiom,
    ! [VarNext] :
      ( v130(VarNext,bitIndex0)
    <=> v174(VarNext,bitIndex0) ) ).

fof(addCaseBooleanConditionEqualRanges1,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v175(VarNext)
       => ! [B] :
            ( range_3_0(B)
           => ( v174(VarNext,B)
            <=> v130(VarCurr,B) ) ) ) ) ).

fof(addCaseBooleanConditionEqualRanges0,axiom,
    ! [VarNext] :
      ( v175(VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v174(VarNext,B)
          <=> v185(VarNext,B) ) ) ) ).

fof(addAssignment_33,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ! [B] :
          ( range_3_0(B)
         => ( v185(VarNext,B)
          <=> v183(VarCurr,B) ) ) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch_1,axiom,
    ! [VarCurr] :
      ( ~ v186(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v183(VarCurr,B)
          <=> v133(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch_1,axiom,
    ! [VarCurr] :
      ( v186(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v183(VarCurr,B)
          <=> $false ) ) ) ).

fof(writeUnaryOperator_2,axiom,
    ! [VarCurr] :
      ( ~ v186(VarCurr)
    <=> v82(VarCurr) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits_1,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v175(VarNext)
      <=> v176(VarNext) ) ) ).

fof(writeBinaryOperatorEqualRangesSingleBits,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v176(VarNext)
      <=> ( v177(VarNext)
          & v166(VarNext) ) ) ) ).

fof(writeUnaryOperator_1,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( ~ v177(VarNext)
      <=> v179(VarNext) ) ) ).

fof(addAssignment_32,axiom,
    ! [VarNext,VarCurr] :
      ( nextState(VarCurr,VarNext)
     => ( v179(VarNext)
      <=> v166(VarCurr) ) ) ).

fof(addAssignment_31,axiom,
    ! [VarCurr] :
      ( v166(VarCurr)
    <=> v168(VarCurr) ) ).

fof(addAssignment_30,axiom,
    ! [VarCurr] :
      ( v168(VarCurr)
    <=> v170(VarCurr) ) ).

fof(addAssignment_29,axiom,
    ! [VarCurr] :
      ( v170(VarCurr)
    <=> v172(VarCurr) ) ).

fof(addAssignment_28,axiom,
    ! [VarCurr] :
      ( v172(VarCurr)
    <=> v1(VarCurr) ) ).

fof(addAssignment_27,axiom,
    ! [VarCurr] :
      ( v133(VarCurr,bitIndex0)
    <=> v149(VarCurr,bitIndex0) ) ).

fof(aaddConditionBooleanCondEqualRangesElseBranch,axiom,
    ! [VarCurr] :
      ( ~ v150(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v149(VarCurr,B)
          <=> v151(VarCurr,B) ) ) ) ).

fof(addConditionBooleanCondEqualRangesThenBranch,axiom,
    ! [VarCurr] :
      ( v150(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v149(VarCurr,B)
          <=> $false ) ) ) ).

fof(bitBlastConstant_12,axiom,
    ~ b0000(bitIndex3) ).

fof(bitBlastConstant_11,axiom,
    ~ b0000(bitIndex2) ).

fof(bitBlastConstant_10,axiom,
    ~ b0000(bitIndex1) ).

fof(bitBlastConstant_9,axiom,
    ~ b0000(bitIndex0) ).

fof(addParallelCaseBooleanConditionEqualRanges3,axiom,
    ! [VarCurr] :
      ( ( ~ v152(VarCurr)
        & ~ v156(VarCurr)
        & ~ v160(VarCurr) )
     => ! [B] :
          ( range_3_0(B)
         => ( v151(VarCurr,B)
          <=> v130(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2_1,axiom,
    ! [VarCurr] :
      ( v160(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v151(VarCurr,B)
          <=> v162(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1_1,axiom,
    ! [VarCurr] :
      ( v156(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v151(VarCurr,B)
          <=> v158(VarCurr,B) ) ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0_1,axiom,
    ! [VarCurr] :
      ( v152(VarCurr)
     => ! [B] :
          ( range_3_0(B)
         => ( v151(VarCurr,B)
          <=> v130(VarCurr,B) ) ) ) ).

fof(range_axiom_2,axiom,
    ! [B] :
      ( range_3_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B ) ) ).

fof(addBitVectorEqualityBitBlasted_5,axiom,
    ! [VarCurr] :
      ( v163(VarCurr)
    <=> ( ( v164(VarCurr,bitIndex1)
        <=> $true )
        & ( v164(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_8,axiom,
    b11(bitIndex1) ).

fof(bitBlastConstant_7,axiom,
    b11(bitIndex0) ).

fof(addAssignment_26,axiom,
    ! [VarCurr] :
      ( v164(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_25,axiom,
    ! [VarCurr] :
      ( v164(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(addAssignment_24,axiom,
    ! [VarCurr] :
      ( v162(VarCurr,bitIndex0)
    <=> $true ) ).

fof(addAssignment_23,axiom,
    ! [VarCurr,B] :
      ( range_3_1(B)
     => ( v162(VarCurr,B)
      <=> v147(VarCurr,B) ) ) ).

fof(range_axiom_1,axiom,
    ! [B] :
      ( range_3_1(B)
    <=> ( $false
        | bitIndex1 = B
        | bitIndex2 = B
        | bitIndex3 = B ) ) ).

fof(addBitVectorEqualityBitBlasted_4,axiom,
    ! [VarCurr] :
      ( v160(VarCurr)
    <=> ( ( v161(VarCurr,bitIndex1)
        <=> $true )
        & ( v161(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(bitBlastConstant_6,axiom,
    b10(bitIndex1) ).

fof(bitBlastConstant_5,axiom,
    ~ b10(bitIndex0) ).

fof(addAssignment_22,axiom,
    ! [VarCurr] :
      ( v161(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_21,axiom,
    ! [VarCurr] :
      ( v161(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(addAssignment_20,axiom,
    ! [VarCurr] :
      ( ( v158(VarCurr,bitIndex2)
      <=> v130(VarCurr,bitIndex3) )
      & ( v158(VarCurr,bitIndex1)
      <=> v130(VarCurr,bitIndex2) )
      & ( v158(VarCurr,bitIndex0)
      <=> v130(VarCurr,bitIndex1) ) ) ).

fof(addAssignment_19,axiom,
    ! [VarCurr] :
      ( v158(VarCurr,bitIndex3)
    <=> $false ) ).

fof(addBitVectorEqualityBitBlasted_3,axiom,
    ! [VarCurr] :
      ( v156(VarCurr)
    <=> ( ( v157(VarCurr,bitIndex1)
        <=> $false )
        & ( v157(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(addAssignment_18,axiom,
    ! [VarCurr] :
      ( v157(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_17,axiom,
    ! [VarCurr] :
      ( v157(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(addAssignmentInitValue,axiom,
    ~ v130(constB0,bitIndex1) ).

fof(bitBlastConstant_4,axiom,
    ~ bxx0x(bitIndex1) ).

fof(addBitVectorEqualityBitBlasted_2,axiom,
    ! [VarCurr] :
      ( v152(VarCurr)
    <=> ( ( v153(VarCurr,bitIndex1)
        <=> $false )
        & ( v153(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignment_16,axiom,
    ! [VarCurr] :
      ( v153(VarCurr,bitIndex0)
    <=> v135(VarCurr) ) ).

fof(addAssignment_15,axiom,
    ! [VarCurr] :
      ( v153(VarCurr,bitIndex1)
    <=> v86(VarCurr) ) ).

fof(writeUnaryOperator,axiom,
    ! [VarCurr] :
      ( ~ v150(VarCurr)
    <=> v82(VarCurr) ) ).

fof(addAssignment_14,axiom,
    ! [VarCurr] :
      ( v135(VarCurr)
    <=> v137(VarCurr) ) ).

fof(addAssignment_13,axiom,
    ! [VarCurr] :
      ( v137(VarCurr)
    <=> v139(VarCurr) ) ).

fof(addParallelCaseBooleanConditionEqualRanges2,axiom,
    ! [VarCurr] :
      ( ( ~ v142(VarCurr)
        & ~ v143(VarCurr) )
     => ( v139(VarCurr)
      <=> $false ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges1,axiom,
    ! [VarCurr] :
      ( v143(VarCurr)
     => ( v139(VarCurr)
      <=> $true ) ) ).

fof(addParallelCaseBooleanConditionEqualRanges0,axiom,
    ! [VarCurr] :
      ( v142(VarCurr)
     => ( v139(VarCurr)
      <=> $false ) ) ).

fof(addBitVectorEqualityBitBlasted_1,axiom,
    ! [VarCurr] :
      ( v143(VarCurr)
    <=> ( ( v69(VarCurr,bitIndex1)
        <=> $false )
        & ( v69(VarCurr,bitIndex0)
        <=> $true ) ) ) ).

fof(bitBlastConstant_3,axiom,
    ~ b01(bitIndex1) ).

fof(bitBlastConstant_2,axiom,
    b01(bitIndex0) ).

fof(addBitVectorEqualityBitBlasted,axiom,
    ! [VarCurr] :
      ( v142(VarCurr)
    <=> ( ( v69(VarCurr,bitIndex1)
        <=> $false )
        & ( v69(VarCurr,bitIndex0)
        <=> $false ) ) ) ).

fof(addAssignmentInitValueVector,axiom,
    ! [B] :
      ( range_1_0(B)
     => ( v69(constB0,B)
      <=> $false ) ) ).

fof(range_axiom,axiom,
    ! [B] :
      ( range_1_0(B)
    <=> ( $false
        | bitIndex0 = B
        | bitIndex1 = B ) ) ).

fof(bitBlastConstant_1,axiom,
    ~ b00(bitIndex1) ).

fof(bitBlastConstant,axiom,
    ~ b00(bitIndex0) ).

fof(addAssignment_12,axiom,
    ! [VarCurr] :
      ( v102(VarCurr)
    <=> v104(VarCurr) ) ).

fof(addAssignment_11,axiom,
    ! [VarCurr] :
      ( v104(VarCurr)
    <=> v106(VarCurr) ) ).

fof(addAssignment_10,axiom,
    ! [VarCurr] :
      ( v106(VarCurr)
    <=> v14(VarCurr) ) ).

fof(addAssignment_9,axiom,
    ! [VarCurr] :
      ( v82(VarCurr)
    <=> v84(VarCurr) ) ).

fof(addAssignment_8,axiom,
    ! [VarCurr] :
      ( v84(VarCurr)
    <=> v51(VarCurr) ) ).

fof(addAssignment_7,axiom,
    ! [VarCurr] :
      ( v51(VarCurr)
    <=> v53(VarCurr) ) ).

fof(addAssignment_6,axiom,
    ! [VarCurr] :
      ( v53(VarCurr)
    <=> v14(VarCurr) ) ).

fof(addAssignment_5,axiom,
    ! [VarCurr] :
      ( v33(VarCurr)
    <=> v35(VarCurr) ) ).

fof(addAssignment_4,axiom,
    ! [VarCurr] :
      ( v35(VarCurr)
    <=> v10(VarCurr) ) ).

fof(addAssignment_3,axiom,
    ! [VarCurr] :
      ( v8(VarCurr)
    <=> v10(VarCurr) ) ).

fof(addAssignment_2,axiom,
    ! [VarCurr] :
      ( v10(VarCurr)
    <=> v12(VarCurr) ) ).

fof(addAssignment_1,axiom,
    ! [VarCurr] :
      ( v12(VarCurr)
    <=> v14(VarCurr) ) ).

fof(addAssignment,axiom,
    ! [VarCurr] :
      ( v14(VarCurr)
    <=> v16(VarCurr) ) ).

%------------------------------------------------------------------------------