java -Xmx6000000000 -jar ./plugins/org.eclipse.equinox.launcher_1.3.100.v20150511-1540.jar -data ./data --generate-csv --csv-dir ../../../releaseScripts/default/UAutomizer-linux/csv -tc ../../../trunk/examples/toolchains/AutomizerC.xml -s ../../../trunk/examples/settings/ai/eq-bench/mempurity-32bit-Automizer_Taipan+AI_EQ_smtcomp.epf -i ../../../trunk/examples/svcomp/forester-heap/sll-01_true-unreach-call_true-valid-memsafety.i -------------------------------------------------------------------------------- This is Ultimate 0.1.23-2f49842 [2018-01-21 10:53:00,375 INFO L170 SettingsManager]: Resetting all preferences to default values... [2018-01-21 10:53:00,376 INFO L174 SettingsManager]: Resetting UltimateCore preferences to default values [2018-01-21 10:53:00,393 INFO L177 SettingsManager]: Ultimate Commandline Interface provides no preferences, ignoring... [2018-01-21 10:53:00,393 INFO L174 SettingsManager]: Resetting Boogie Preprocessor preferences to default values [2018-01-21 10:53:00,394 INFO L174 SettingsManager]: Resetting Boogie Procedure Inliner preferences to default values [2018-01-21 10:53:00,395 INFO L174 SettingsManager]: Resetting Abstract Interpretation preferences to default values [2018-01-21 10:53:00,397 INFO L174 SettingsManager]: Resetting LassoRanker preferences to default values [2018-01-21 10:53:00,399 INFO L174 SettingsManager]: Resetting Reaching Definitions preferences to default values [2018-01-21 10:53:00,400 INFO L174 SettingsManager]: Resetting SyntaxChecker preferences to default values [2018-01-21 10:53:00,401 INFO L177 SettingsManager]: Büchi Program Product provides no preferences, ignoring... [2018-01-21 10:53:00,401 INFO L174 SettingsManager]: Resetting LTL2Aut preferences to default values [2018-01-21 10:53:00,402 INFO L174 SettingsManager]: Resetting BlockEncodingV2 preferences to default values [2018-01-21 10:53:00,404 INFO L174 SettingsManager]: Resetting AutomataScriptInterpreter preferences to default values [2018-01-21 10:53:00,405 INFO L174 SettingsManager]: Resetting BuchiAutomizer preferences to default values [2018-01-21 10:53:00,407 INFO L174 SettingsManager]: Resetting CACSL2BoogieTranslator preferences to default values [2018-01-21 10:53:00,410 INFO L174 SettingsManager]: Resetting CodeCheck preferences to default values [2018-01-21 10:53:00,412 INFO L174 SettingsManager]: Resetting InvariantSynthesis preferences to default values [2018-01-21 10:53:00,413 INFO L174 SettingsManager]: Resetting RCFGBuilder preferences to default values [2018-01-21 10:53:00,415 INFO L174 SettingsManager]: Resetting TraceAbstraction preferences to default values [2018-01-21 10:53:00,418 INFO L177 SettingsManager]: TraceAbstractionConcurrent provides no preferences, ignoring... [2018-01-21 10:53:00,418 INFO L177 SettingsManager]: TraceAbstractionWithAFAs provides no preferences, ignoring... [2018-01-21 10:53:00,418 INFO L174 SettingsManager]: Resetting IcfgTransformer preferences to default values [2018-01-21 10:53:00,419 INFO L174 SettingsManager]: Resetting Boogie Printer preferences to default values [2018-01-21 10:53:00,420 INFO L174 SettingsManager]: Resetting Witness Printer preferences to default values [2018-01-21 10:53:00,422 INFO L177 SettingsManager]: Boogie PL CUP Parser provides no preferences, ignoring... [2018-01-21 10:53:00,422 INFO L174 SettingsManager]: Resetting CDTParser preferences to default values [2018-01-21 10:53:00,423 INFO L177 SettingsManager]: PEA to Boogie provides no preferences, ignoring... [2018-01-21 10:53:00,423 INFO L177 SettingsManager]: AutomataScriptParser provides no preferences, ignoring... [2018-01-21 10:53:00,423 INFO L174 SettingsManager]: Resetting Witness Parser preferences to default values [2018-01-21 10:53:00,424 INFO L181 SettingsManager]: Finished resetting all preferences to default values... [2018-01-21 10:53:00,424 INFO L98 SettingsManager]: Beginning loading settings from /storage/ultimate/releaseScripts/default/UAutomizer-linux/../../../trunk/examples/settings/ai/eq-bench/mempurity-32bit-Automizer_Taipan+AI_EQ_smtcomp.epf [2018-01-21 10:53:00,433 INFO L110 SettingsManager]: Loading preferences was successful [2018-01-21 10:53:00,434 INFO L112 SettingsManager]: Preferences different from defaults after loading the file: [2018-01-21 10:53:00,434 INFO L131 SettingsManager]: Preferences of Boogie Procedure Inliner differ from their defaults: [2018-01-21 10:53:00,435 INFO L133 SettingsManager]: * to procedures, called more than once=true [2018-01-21 10:53:00,435 INFO L131 SettingsManager]: Preferences of Abstract Interpretation differ from their defaults: [2018-01-21 10:53:00,435 INFO L133 SettingsManager]: * Abstract domain for RCFG-of-the-future=VPDomain [2018-01-21 10:53:00,435 INFO L133 SettingsManager]: * Precise comparison operator=true [2018-01-21 10:53:00,435 INFO L133 SettingsManager]: * Use the RCFG-of-the-future interface=true [2018-01-21 10:53:00,436 INFO L131 SettingsManager]: Preferences of CACSL2BoogieTranslator differ from their defaults: [2018-01-21 10:53:00,436 INFO L133 SettingsManager]: * sizeof long=4 [2018-01-21 10:53:00,436 INFO L133 SettingsManager]: * Check unreachability of error function in SV-COMP mode=false [2018-01-21 10:53:00,436 INFO L133 SettingsManager]: * Check allocation purity=true [2018-01-21 10:53:00,436 INFO L133 SettingsManager]: * Overapproximate operations on floating types=true [2018-01-21 10:53:00,436 INFO L133 SettingsManager]: * sizeof POINTER=4 [2018-01-21 10:53:00,437 INFO L133 SettingsManager]: * Check division by zero=IGNORE [2018-01-21 10:53:00,437 INFO L133 SettingsManager]: * Pointer to allocated memory at dereference=IGNORE [2018-01-21 10:53:00,437 INFO L133 SettingsManager]: * If two pointers are subtracted or compared they have the same base address=IGNORE [2018-01-21 10:53:00,437 INFO L133 SettingsManager]: * Check array bounds for arrays that are off heap=IGNORE [2018-01-21 10:53:00,437 INFO L133 SettingsManager]: * sizeof long double=12 [2018-01-21 10:53:00,437 INFO L133 SettingsManager]: * Check if freed pointer was valid=false [2018-01-21 10:53:00,437 INFO L133 SettingsManager]: * Pointer base address is valid at dereference=IGNORE [2018-01-21 10:53:00,438 INFO L131 SettingsManager]: Preferences of RCFGBuilder differ from their defaults: [2018-01-21 10:53:00,438 INFO L133 SettingsManager]: * Size of a code block=SequenceOfStatements [2018-01-21 10:53:00,438 INFO L133 SettingsManager]: * To the following directory=./dump/ [2018-01-21 10:53:00,438 INFO L133 SettingsManager]: * Add additional assume for each assert=false [2018-01-21 10:53:00,438 INFO L133 SettingsManager]: * SMT solver=External_DefaultMode [2018-01-21 10:53:00,439 INFO L133 SettingsManager]: * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in -t:2000 [2018-01-21 10:53:00,439 INFO L131 SettingsManager]: Preferences of TraceAbstraction differ from their defaults: [2018-01-21 10:53:00,439 INFO L133 SettingsManager]: * Interpolant automaton=TWOTRACK [2018-01-21 10:53:00,439 INFO L133 SettingsManager]: * Compute Interpolants along a Counterexample=FPandBP [2018-01-21 10:53:00,439 INFO L133 SettingsManager]: * Positions where we compute the Hoare Annotation=LoopsAndPotentialCycles [2018-01-21 10:53:00,439 INFO L133 SettingsManager]: * Stop after first violation was found=false [2018-01-21 10:53:00,439 INFO L133 SettingsManager]: * Trace refinement strategy=TAIPAN [2018-01-21 10:53:00,439 INFO L133 SettingsManager]: * SMT solver=External_ModelsAndUnsatCoreMode [2018-01-21 10:53:00,440 INFO L133 SettingsManager]: * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in [2018-01-21 10:53:00,440 INFO L133 SettingsManager]: * Compute Hoare Annotation of negated interpolant automaton, abstraction and CFG=true [2018-01-21 10:53:00,440 INFO L133 SettingsManager]: * Abstract interpretation Mode=USE_PREDICATES [2018-01-21 10:53:00,440 INFO L131 SettingsManager]: Preferences of IcfgTransformer differ from their defaults: [2018-01-21 10:53:00,441 INFO L133 SettingsManager]: * TransformationType=HEAP_SEPARATOR [2018-01-21 10:53:00,475 INFO L81 nceAwareModelManager]: Repository-Root is: /tmp [2018-01-21 10:53:00,486 INFO L266 ainManager$Toolchain]: [Toolchain 1]: Parser(s) successfully initialized [2018-01-21 10:53:00,489 INFO L222 ainManager$Toolchain]: [Toolchain 1]: Toolchain data selected. [2018-01-21 10:53:00,491 INFO L271 PluginConnector]: Initializing CDTParser... [2018-01-21 10:53:00,491 INFO L276 PluginConnector]: CDTParser initialized [2018-01-21 10:53:00,492 INFO L431 ainManager$Toolchain]: [Toolchain 1]: Parsing single file: /storage/ultimate/releaseScripts/default/UAutomizer-linux/../../../trunk/examples/svcomp/forester-heap/sll-01_true-unreach-call_true-valid-memsafety.i [2018-01-21 10:53:00,684 INFO L304 ainManager$Toolchain]: ####################### [Toolchain 1] ####################### [2018-01-21 10:53:00,689 INFO L131 ToolchainWalker]: Walking toolchain with 4 elements. [2018-01-21 10:53:00,690 INFO L113 PluginConnector]: ------------------------CACSL2BoogieTranslator---------------------------- [2018-01-21 10:53:00,690 INFO L271 PluginConnector]: Initializing CACSL2BoogieTranslator... [2018-01-21 10:53:00,696 INFO L276 PluginConnector]: CACSL2BoogieTranslator initialized [2018-01-21 10:53:00,697 INFO L185 PluginConnector]: Executing the observer ACSLObjectContainerObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 21.01 10:53:00" (1/1) ... [2018-01-21 10:53:00,700 INFO L205 PluginConnector]: Invalid model from CACSL2BoogieTranslator for observer de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator.ACSLObjectContainerObserver@2b75990c and model type de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 21.01 10:53:00, skipping insertion in model container [2018-01-21 10:53:00,700 INFO L185 PluginConnector]: Executing the observer CACSL2BoogieTranslatorObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 21.01 10:53:00" (1/1) ... [2018-01-21 10:53:00,714 INFO L153 Dispatcher]: Using SV-COMP mode [2018-01-21 10:53:00,758 INFO L153 Dispatcher]: Using SV-COMP mode [2018-01-21 10:53:00,884 INFO L450 PostProcessor]: Settings: Checked method=main [2018-01-21 10:53:00,906 INFO L450 PostProcessor]: Settings: Checked method=main [2018-01-21 10:53:00,915 INFO L202 PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 21.01 10:53:00 WrapperNode [2018-01-21 10:53:00,915 INFO L132 PluginConnector]: ------------------------ END CACSL2BoogieTranslator---------------------------- [2018-01-21 10:53:00,916 INFO L113 PluginConnector]: ------------------------Boogie Preprocessor---------------------------- [2018-01-21 10:53:00,916 INFO L271 PluginConnector]: Initializing Boogie Preprocessor... [2018-01-21 10:53:00,916 INFO L276 PluginConnector]: Boogie Preprocessor initialized [2018-01-21 10:53:00,927 INFO L185 PluginConnector]: Executing the observer EnsureBoogieModelObserver from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 21.01 10:53:00" (1/1) ... [2018-01-21 10:53:00,927 INFO L185 PluginConnector]: Executing the observer TypeChecker from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 21.01 10:53:00" (1/1) ... [2018-01-21 10:53:00,937 INFO L185 PluginConnector]: Executing the observer ConstExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 21.01 10:53:00" (1/1) ... [2018-01-21 10:53:00,937 INFO L185 PluginConnector]: Executing the observer StructExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 21.01 10:53:00" (1/1) ... [2018-01-21 10:53:00,945 INFO L185 PluginConnector]: Executing the observer UnstructureCode from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 21.01 10:53:00" (1/1) ... [2018-01-21 10:53:00,950 INFO L185 PluginConnector]: Executing the observer FunctionInliner from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 21.01 10:53:00" (1/1) ... [2018-01-21 10:53:00,951 INFO L185 PluginConnector]: Executing the observer BoogieSymbolTableConstructor from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 21.01 10:53:00" (1/1) ... [2018-01-21 10:53:00,954 INFO L132 PluginConnector]: ------------------------ END Boogie Preprocessor---------------------------- [2018-01-21 10:53:00,954 INFO L113 PluginConnector]: ------------------------RCFGBuilder---------------------------- [2018-01-21 10:53:00,954 INFO L271 PluginConnector]: Initializing RCFGBuilder... [2018-01-21 10:53:00,955 INFO L276 PluginConnector]: RCFGBuilder initialized [2018-01-21 10:53:00,956 INFO L185 PluginConnector]: Executing the observer RCFGBuilderObserver from plugin RCFGBuilder for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 21.01 10:53:00" (1/1) ... No working directory specified, using /storage/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 1 with z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in -t:2000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 1 with z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in -t:2000 [2018-01-21 10:53:01,002 INFO L136 BoogieDeclarations]: Found implementation of procedure ULTIMATE.init [2018-01-21 10:53:01,003 INFO L136 BoogieDeclarations]: Found implementation of procedure ULTIMATE.start [2018-01-21 10:53:01,003 INFO L136 BoogieDeclarations]: Found implementation of procedure main [2018-01-21 10:53:01,003 INFO L128 BoogieDeclarations]: Found specification of procedure write~$Pointer$ [2018-01-21 10:53:01,003 INFO L128 BoogieDeclarations]: Found specification of procedure read~$Pointer$ [2018-01-21 10:53:01,003 INFO L128 BoogieDeclarations]: Found specification of procedure ULTIMATE.free [2018-01-21 10:53:01,003 INFO L128 BoogieDeclarations]: Found specification of procedure ULTIMATE.dealloc [2018-01-21 10:53:01,003 INFO L128 BoogieDeclarations]: Found specification of procedure #Ultimate.alloc [2018-01-21 10:53:01,003 INFO L128 BoogieDeclarations]: Found specification of procedure malloc [2018-01-21 10:53:01,003 INFO L128 BoogieDeclarations]: Found specification of procedure free [2018-01-21 10:53:01,003 INFO L128 BoogieDeclarations]: Found specification of procedure __VERIFIER_nondet_int [2018-01-21 10:53:01,004 INFO L128 BoogieDeclarations]: Found specification of procedure __VERIFIER_error [2018-01-21 10:53:01,004 INFO L128 BoogieDeclarations]: Found specification of procedure main [2018-01-21 10:53:01,004 INFO L128 BoogieDeclarations]: Found specification of procedure ULTIMATE.init [2018-01-21 10:53:01,004 INFO L128 BoogieDeclarations]: Found specification of procedure ULTIMATE.start [2018-01-21 10:53:01,448 INFO L257 CfgBuilder]: Using the 1 location(s) as analysis (start of procedure ULTIMATE.start) [2018-01-21 10:53:01,448 INFO L202 PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 21.01 10:53:01 BoogieIcfgContainer [2018-01-21 10:53:01,449 INFO L132 PluginConnector]: ------------------------ END RCFGBuilder---------------------------- [2018-01-21 10:53:01,450 INFO L113 PluginConnector]: ------------------------TraceAbstraction---------------------------- [2018-01-21 10:53:01,450 INFO L271 PluginConnector]: Initializing TraceAbstraction... [2018-01-21 10:53:01,452 INFO L276 PluginConnector]: TraceAbstraction initialized [2018-01-21 10:53:01,453 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "CDTParser AST 21.01 10:53:00" (1/3) ... [2018-01-21 10:53:01,454 INFO L205 PluginConnector]: Invalid model from TraceAbstraction for observer de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionObserver@8f67937 and model type de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction AST 21.01 10:53:01, skipping insertion in model container [2018-01-21 10:53:01,454 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 21.01 10:53:00" (2/3) ... [2018-01-21 10:53:01,454 INFO L205 PluginConnector]: Invalid model from TraceAbstraction for observer de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionObserver@8f67937 and model type de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction AST 21.01 10:53:01, skipping insertion in model container [2018-01-21 10:53:01,455 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 21.01 10:53:01" (3/3) ... [2018-01-21 10:53:01,456 INFO L105 eAbstractionObserver]: Analyzing ICFG sll-01_true-unreach-call_true-valid-memsafety.i [2018-01-21 10:53:01,463 INFO L130 ceAbstractionStarter]: Automizer settings: Hoare:true NWA Interpolation:FPandBP Determinization: PREDICATE_ABSTRACTION [2018-01-21 10:53:01,470 INFO L142 ceAbstractionStarter]: Appying trace abstraction to program that has 3 error locations. [2018-01-21 10:53:01,511 INFO L322 AbstractCegarLoop]: Interprodecural is true [2018-01-21 10:53:01,511 INFO L323 AbstractCegarLoop]: Hoare is true [2018-01-21 10:53:01,511 INFO L324 AbstractCegarLoop]: Compute interpolants for FPandBP [2018-01-21 10:53:01,511 INFO L325 AbstractCegarLoop]: Backedges is TWOTRACK [2018-01-21 10:53:01,512 INFO L326 AbstractCegarLoop]: Determinization is PREDICATE_ABSTRACTION [2018-01-21 10:53:01,512 INFO L327 AbstractCegarLoop]: Difference is false [2018-01-21 10:53:01,512 INFO L328 AbstractCegarLoop]: Minimize is MINIMIZE_SEVPA [2018-01-21 10:53:01,512 INFO L333 AbstractCegarLoop]: ======== Iteration 0==of CEGAR loop == ULTIMATE.initErr0EnsuresViolation======== [2018-01-21 10:53:01,513 INFO L87 2NestedWordAutomaton]: Mode: main mode - execution starts in main procedure [2018-01-21 10:53:01,530 INFO L276 IsEmpty]: Start isEmpty. Operand 123 states. [2018-01-21 10:53:01,536 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 4 [2018-01-21 10:53:01,536 INFO L314 BasicCegarLoop]: Found error trace [2018-01-21 10:53:01,537 INFO L322 BasicCegarLoop]: trace histogram [1, 1, 1] [2018-01-21 10:53:01,537 INFO L371 AbstractCegarLoop]: === Iteration 1 === [ULTIMATE.initErr0EnsuresViolation]=== [2018-01-21 10:53:01,541 INFO L82 PathProgramCache]: Analyzing trace with hash 393051, now seen corresponding path program 1 times [2018-01-21 10:53:01,543 INFO L67 tionRefinementEngine]: Using refinement strategy TaipanRefinementStrategy [2018-01-21 10:53:01,584 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:01,584 INFO L101 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-01-21 10:53:01,584 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:01,584 INFO L280 anRefinementStrategy]: Using traceCheck mode SMTINTERPOL with AssertCodeBlockOrder NOT_INCREMENTALLY (IT: Craig_TreeInterpolation) [2018-01-21 10:53:01,614 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is sat [2018-01-21 10:53:01,620 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is sat [2018-01-21 10:53:01,637 INFO L381 BasicCegarLoop]: Counterexample might be feasible [2018-01-21 10:53:01,643 WARN L343 cessorBacktranslator]: Generated EnsuresSpecification ensures #valid == old(#valid); is not ensure(true) [2018-01-21 10:53:01,651 INFO L322 AbstractCegarLoop]: Interprodecural is true [2018-01-21 10:53:01,651 INFO L323 AbstractCegarLoop]: Hoare is true [2018-01-21 10:53:01,651 INFO L324 AbstractCegarLoop]: Compute interpolants for FPandBP [2018-01-21 10:53:01,651 INFO L325 AbstractCegarLoop]: Backedges is TWOTRACK [2018-01-21 10:53:01,652 INFO L326 AbstractCegarLoop]: Determinization is PREDICATE_ABSTRACTION [2018-01-21 10:53:01,652 INFO L327 AbstractCegarLoop]: Difference is false [2018-01-21 10:53:01,652 INFO L328 AbstractCegarLoop]: Minimize is MINIMIZE_SEVPA [2018-01-21 10:53:01,652 INFO L333 AbstractCegarLoop]: ======== Iteration 0==of CEGAR loop == ULTIMATE.startErr0EnsuresViolation======== [2018-01-21 10:53:01,652 INFO L87 2NestedWordAutomaton]: Mode: main mode - execution starts in main procedure [2018-01-21 10:53:01,656 INFO L276 IsEmpty]: Start isEmpty. Operand 123 states. [2018-01-21 10:53:01,658 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 24 [2018-01-21 10:53:01,659 INFO L314 BasicCegarLoop]: Found error trace [2018-01-21 10:53:01,659 INFO L322 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-01-21 10:53:01,659 INFO L371 AbstractCegarLoop]: === Iteration 1 === [ULTIMATE.startErr0EnsuresViolation]=== [2018-01-21 10:53:01,659 INFO L82 PathProgramCache]: Analyzing trace with hash -232031712, now seen corresponding path program 1 times [2018-01-21 10:53:01,659 INFO L67 tionRefinementEngine]: Using refinement strategy TaipanRefinementStrategy [2018-01-21 10:53:01,660 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:01,660 INFO L101 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-01-21 10:53:01,660 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:01,660 INFO L280 anRefinementStrategy]: Using traceCheck mode SMTINTERPOL with AssertCodeBlockOrder NOT_INCREMENTALLY (IT: Craig_TreeInterpolation) [2018-01-21 10:53:01,674 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-01-21 10:53:01,681 WARN L137 erpolLogProxyWrapper]: Using partial proofs (cut at CNF-level). Set option :produce-proofs to true to get complete proofs. [2018-01-21 10:53:01,717 INFO L134 CoverageAnalysis]: Checked inductivity of 0 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-01-21 10:53:01,719 INFO L320 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-01-21 10:53:01,719 INFO L335 seRefinementStrategy]: Number of different interpolants: perfect sequences [2] imperfect sequences [] total 2 [2018-01-21 10:53:01,720 INFO L252 anRefinementStrategy]: Using the first perfect interpolant sequence [2018-01-21 10:53:01,723 INFO L409 AbstractCegarLoop]: Interpolant automaton has 2 states [2018-01-21 10:53:01,832 INFO L132 InterpolantAutomaton]: Constructing interpolant automaton starting with 2 interpolants. [2018-01-21 10:53:01,833 INFO L133 InterpolantAutomaton]: CoverageRelationStatistics Valid=1, Invalid=1, Unknown=0, NotChecked=0, Total=2 [2018-01-21 10:53:01,835 INFO L87 Difference]: Start difference. First operand 123 states. Second operand 2 states. [2018-01-21 10:53:01,867 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-01-21 10:53:01,868 INFO L93 Difference]: Finished difference Result 237 states and 341 transitions. [2018-01-21 10:53:01,868 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 2 states. [2018-01-21 10:53:01,869 INFO L78 Accepts]: Start accepts. Automaton has 2 states. Word has length 23 [2018-01-21 10:53:01,869 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-01-21 10:53:01,879 INFO L225 Difference]: With dead ends: 237 [2018-01-21 10:53:01,879 INFO L226 Difference]: Without dead ends: 120 [2018-01-21 10:53:01,882 INFO L525 BasicCegarLoop]: 0 DeclaredPredicates, 2 GetRequests, 2 SyntacticMatches, 0 SemanticMatches, 0 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=1, Invalid=1, Unknown=0, NotChecked=0, Total=2 [2018-01-21 10:53:01,896 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 120 states. [2018-01-21 10:53:01,914 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 120 to 120. [2018-01-21 10:53:01,915 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 120 states. [2018-01-21 10:53:01,916 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 120 states to 120 states and 129 transitions. [2018-01-21 10:53:01,918 INFO L78 Accepts]: Start accepts. Automaton has 120 states and 129 transitions. Word has length 23 [2018-01-21 10:53:01,918 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-01-21 10:53:01,918 INFO L432 AbstractCegarLoop]: Abstraction has 120 states and 129 transitions. [2018-01-21 10:53:01,918 INFO L433 AbstractCegarLoop]: Interpolant automaton has 2 states. [2018-01-21 10:53:01,918 INFO L276 IsEmpty]: Start isEmpty. Operand 120 states and 129 transitions. [2018-01-21 10:53:01,919 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 37 [2018-01-21 10:53:01,919 INFO L314 BasicCegarLoop]: Found error trace [2018-01-21 10:53:01,919 INFO L322 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-01-21 10:53:01,920 INFO L371 AbstractCegarLoop]: === Iteration 2 === [ULTIMATE.startErr0EnsuresViolation]=== [2018-01-21 10:53:01,920 INFO L82 PathProgramCache]: Analyzing trace with hash -448715966, now seen corresponding path program 1 times [2018-01-21 10:53:01,920 INFO L67 tionRefinementEngine]: Using refinement strategy TaipanRefinementStrategy [2018-01-21 10:53:01,921 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:01,921 INFO L101 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-01-21 10:53:01,921 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:01,921 INFO L280 anRefinementStrategy]: Using traceCheck mode SMTINTERPOL with AssertCodeBlockOrder NOT_INCREMENTALLY (IT: Craig_TreeInterpolation) [2018-01-21 10:53:01,946 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-01-21 10:53:01,947 WARN L137 erpolLogProxyWrapper]: Using partial proofs (cut at CNF-level). Set option :produce-proofs to true to get complete proofs. [2018-01-21 10:53:02,086 INFO L134 CoverageAnalysis]: Checked inductivity of 0 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-01-21 10:53:02,086 INFO L320 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-01-21 10:53:02,116 INFO L335 seRefinementStrategy]: Number of different interpolants: perfect sequences [5] imperfect sequences [] total 5 [2018-01-21 10:53:02,117 INFO L252 anRefinementStrategy]: Using the first perfect interpolant sequence [2018-01-21 10:53:02,118 INFO L409 AbstractCegarLoop]: Interpolant automaton has 5 states [2018-01-21 10:53:02,118 INFO L132 InterpolantAutomaton]: Constructing interpolant automaton starting with 5 interpolants. [2018-01-21 10:53:02,118 INFO L133 InterpolantAutomaton]: CoverageRelationStatistics Valid=7, Invalid=13, Unknown=0, NotChecked=0, Total=20 [2018-01-21 10:53:02,119 INFO L87 Difference]: Start difference. First operand 120 states and 129 transitions. Second operand 5 states. [2018-01-21 10:53:02,368 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-01-21 10:53:02,368 INFO L93 Difference]: Finished difference Result 280 states and 303 transitions. [2018-01-21 10:53:02,369 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 6 states. [2018-01-21 10:53:02,369 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 36 [2018-01-21 10:53:02,369 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-01-21 10:53:02,373 INFO L225 Difference]: With dead ends: 280 [2018-01-21 10:53:02,373 INFO L226 Difference]: Without dead ends: 188 [2018-01-21 10:53:02,374 INFO L525 BasicCegarLoop]: 0 DeclaredPredicates, 7 GetRequests, 2 SyntacticMatches, 0 SemanticMatches, 5 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=17, Invalid=25, Unknown=0, NotChecked=0, Total=42 [2018-01-21 10:53:02,374 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 188 states. [2018-01-21 10:53:02,381 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 188 to 124. [2018-01-21 10:53:02,381 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 124 states. [2018-01-21 10:53:02,383 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 124 states to 124 states and 133 transitions. [2018-01-21 10:53:02,384 INFO L78 Accepts]: Start accepts. Automaton has 124 states and 133 transitions. Word has length 36 [2018-01-21 10:53:02,384 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-01-21 10:53:02,384 INFO L432 AbstractCegarLoop]: Abstraction has 124 states and 133 transitions. [2018-01-21 10:53:02,384 INFO L433 AbstractCegarLoop]: Interpolant automaton has 5 states. [2018-01-21 10:53:02,384 INFO L276 IsEmpty]: Start isEmpty. Operand 124 states and 133 transitions. [2018-01-21 10:53:02,385 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 39 [2018-01-21 10:53:02,386 INFO L314 BasicCegarLoop]: Found error trace [2018-01-21 10:53:02,386 INFO L322 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-01-21 10:53:02,386 INFO L371 AbstractCegarLoop]: === Iteration 3 === [ULTIMATE.startErr0EnsuresViolation]=== [2018-01-21 10:53:02,386 INFO L82 PathProgramCache]: Analyzing trace with hash -1412768891, now seen corresponding path program 1 times [2018-01-21 10:53:02,386 INFO L67 tionRefinementEngine]: Using refinement strategy TaipanRefinementStrategy [2018-01-21 10:53:02,387 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:02,387 INFO L101 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-01-21 10:53:02,387 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:02,388 INFO L280 anRefinementStrategy]: Using traceCheck mode SMTINTERPOL with AssertCodeBlockOrder NOT_INCREMENTALLY (IT: Craig_TreeInterpolation) [2018-01-21 10:53:02,402 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-01-21 10:53:02,402 WARN L137 erpolLogProxyWrapper]: Using partial proofs (cut at CNF-level). Set option :produce-proofs to true to get complete proofs. [2018-01-21 10:53:02,457 INFO L134 CoverageAnalysis]: Checked inductivity of 0 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-01-21 10:53:02,458 INFO L320 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-01-21 10:53:02,458 INFO L335 seRefinementStrategy]: Number of different interpolants: perfect sequences [5] imperfect sequences [] total 5 [2018-01-21 10:53:02,458 INFO L252 anRefinementStrategy]: Using the first perfect interpolant sequence [2018-01-21 10:53:02,459 INFO L409 AbstractCegarLoop]: Interpolant automaton has 5 states [2018-01-21 10:53:02,459 INFO L132 InterpolantAutomaton]: Constructing interpolant automaton starting with 5 interpolants. [2018-01-21 10:53:02,459 INFO L133 InterpolantAutomaton]: CoverageRelationStatistics Valid=7, Invalid=13, Unknown=0, NotChecked=0, Total=20 [2018-01-21 10:53:02,459 INFO L87 Difference]: Start difference. First operand 124 states and 133 transitions. Second operand 5 states. [2018-01-21 10:53:02,613 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-01-21 10:53:02,613 INFO L93 Difference]: Finished difference Result 206 states and 222 transitions. [2018-01-21 10:53:02,613 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 5 states. [2018-01-21 10:53:02,613 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 38 [2018-01-21 10:53:02,614 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-01-21 10:53:02,616 INFO L225 Difference]: With dead ends: 206 [2018-01-21 10:53:02,616 INFO L226 Difference]: Without dead ends: 179 [2018-01-21 10:53:02,617 INFO L525 BasicCegarLoop]: 0 DeclaredPredicates, 7 GetRequests, 2 SyntacticMatches, 0 SemanticMatches, 5 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=17, Invalid=25, Unknown=0, NotChecked=0, Total=42 [2018-01-21 10:53:02,617 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 179 states. [2018-01-21 10:53:02,627 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 179 to 128. [2018-01-21 10:53:02,627 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 128 states. [2018-01-21 10:53:02,628 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 128 states to 128 states and 137 transitions. [2018-01-21 10:53:02,629 INFO L78 Accepts]: Start accepts. Automaton has 128 states and 137 transitions. Word has length 38 [2018-01-21 10:53:02,629 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-01-21 10:53:02,629 INFO L432 AbstractCegarLoop]: Abstraction has 128 states and 137 transitions. [2018-01-21 10:53:02,629 INFO L433 AbstractCegarLoop]: Interpolant automaton has 5 states. [2018-01-21 10:53:02,629 INFO L276 IsEmpty]: Start isEmpty. Operand 128 states and 137 transitions. [2018-01-21 10:53:02,631 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 59 [2018-01-21 10:53:02,632 INFO L314 BasicCegarLoop]: Found error trace [2018-01-21 10:53:02,632 INFO L322 BasicCegarLoop]: trace histogram [2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-01-21 10:53:02,632 INFO L371 AbstractCegarLoop]: === Iteration 4 === [ULTIMATE.startErr0EnsuresViolation]=== [2018-01-21 10:53:02,632 INFO L82 PathProgramCache]: Analyzing trace with hash -812324167, now seen corresponding path program 1 times [2018-01-21 10:53:02,633 INFO L67 tionRefinementEngine]: Using refinement strategy TaipanRefinementStrategy [2018-01-21 10:53:02,634 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:02,634 INFO L101 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-01-21 10:53:02,634 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:02,634 INFO L280 anRefinementStrategy]: Using traceCheck mode SMTINTERPOL with AssertCodeBlockOrder NOT_INCREMENTALLY (IT: Craig_TreeInterpolation) [2018-01-21 10:53:02,656 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is sat [2018-01-21 10:53:02,679 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is sat [2018-01-21 10:53:02,693 INFO L381 BasicCegarLoop]: Counterexample might be feasible [2018-01-21 10:53:02,705 WARN L343 cessorBacktranslator]: Generated EnsuresSpecification ensures #valid == old(#valid); is not ensure(true) [2018-01-21 10:53:02,715 WARN L343 cessorBacktranslator]: Generated EnsuresSpecification ensures #valid == old(#valid); is not ensure(true) [2018-01-21 10:53:02,716 WARN L343 cessorBacktranslator]: Generated EnsuresSpecification ensures #valid == old(#valid); is not ensure(true) [2018-01-21 10:53:02,735 INFO L322 AbstractCegarLoop]: Interprodecural is true [2018-01-21 10:53:02,735 INFO L323 AbstractCegarLoop]: Hoare is true [2018-01-21 10:53:02,735 INFO L324 AbstractCegarLoop]: Compute interpolants for FPandBP [2018-01-21 10:53:02,735 INFO L325 AbstractCegarLoop]: Backedges is TWOTRACK [2018-01-21 10:53:02,736 INFO L326 AbstractCegarLoop]: Determinization is PREDICATE_ABSTRACTION [2018-01-21 10:53:02,736 INFO L327 AbstractCegarLoop]: Difference is false [2018-01-21 10:53:02,736 INFO L328 AbstractCegarLoop]: Minimize is MINIMIZE_SEVPA [2018-01-21 10:53:02,736 INFO L333 AbstractCegarLoop]: ======== Iteration 0==of CEGAR loop == mainErr0EnsuresViolation======== [2018-01-21 10:53:02,736 INFO L87 2NestedWordAutomaton]: Mode: main mode - execution starts in main procedure [2018-01-21 10:53:02,738 INFO L276 IsEmpty]: Start isEmpty. Operand 123 states. [2018-01-21 10:53:02,739 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 22 [2018-01-21 10:53:02,740 INFO L314 BasicCegarLoop]: Found error trace [2018-01-21 10:53:02,740 INFO L322 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-01-21 10:53:02,740 INFO L371 AbstractCegarLoop]: === Iteration 1 === [mainErr0EnsuresViolation]=== [2018-01-21 10:53:02,740 INFO L82 PathProgramCache]: Analyzing trace with hash -1381245512, now seen corresponding path program 1 times [2018-01-21 10:53:02,740 INFO L67 tionRefinementEngine]: Using refinement strategy TaipanRefinementStrategy [2018-01-21 10:53:02,741 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:02,741 INFO L101 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-01-21 10:53:02,742 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:02,742 INFO L280 anRefinementStrategy]: Using traceCheck mode SMTINTERPOL with AssertCodeBlockOrder NOT_INCREMENTALLY (IT: Craig_TreeInterpolation) [2018-01-21 10:53:02,747 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-01-21 10:53:02,748 WARN L137 erpolLogProxyWrapper]: Using partial proofs (cut at CNF-level). Set option :produce-proofs to true to get complete proofs. [2018-01-21 10:53:02,757 INFO L134 CoverageAnalysis]: Checked inductivity of 0 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-01-21 10:53:02,757 INFO L320 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-01-21 10:53:02,757 INFO L335 seRefinementStrategy]: Number of different interpolants: perfect sequences [2] imperfect sequences [] total 2 [2018-01-21 10:53:02,757 INFO L252 anRefinementStrategy]: Using the first perfect interpolant sequence [2018-01-21 10:53:02,758 INFO L409 AbstractCegarLoop]: Interpolant automaton has 2 states [2018-01-21 10:53:02,758 INFO L132 InterpolantAutomaton]: Constructing interpolant automaton starting with 2 interpolants. [2018-01-21 10:53:02,758 INFO L133 InterpolantAutomaton]: CoverageRelationStatistics Valid=1, Invalid=1, Unknown=0, NotChecked=0, Total=2 [2018-01-21 10:53:02,758 INFO L87 Difference]: Start difference. First operand 123 states. Second operand 2 states. [2018-01-21 10:53:02,764 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-01-21 10:53:02,764 INFO L93 Difference]: Finished difference Result 237 states and 341 transitions. [2018-01-21 10:53:02,764 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 2 states. [2018-01-21 10:53:02,764 INFO L78 Accepts]: Start accepts. Automaton has 2 states. Word has length 21 [2018-01-21 10:53:02,764 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-01-21 10:53:02,766 INFO L225 Difference]: With dead ends: 237 [2018-01-21 10:53:02,766 INFO L226 Difference]: Without dead ends: 118 [2018-01-21 10:53:02,767 INFO L525 BasicCegarLoop]: 0 DeclaredPredicates, 2 GetRequests, 2 SyntacticMatches, 0 SemanticMatches, 0 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=1, Invalid=1, Unknown=0, NotChecked=0, Total=2 [2018-01-21 10:53:02,767 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 118 states. [2018-01-21 10:53:02,774 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 118 to 118. [2018-01-21 10:53:02,774 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 118 states. [2018-01-21 10:53:02,775 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 118 states to 118 states and 127 transitions. [2018-01-21 10:53:02,775 INFO L78 Accepts]: Start accepts. Automaton has 118 states and 127 transitions. Word has length 21 [2018-01-21 10:53:02,776 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-01-21 10:53:02,776 INFO L432 AbstractCegarLoop]: Abstraction has 118 states and 127 transitions. [2018-01-21 10:53:02,776 INFO L433 AbstractCegarLoop]: Interpolant automaton has 2 states. [2018-01-21 10:53:02,776 INFO L276 IsEmpty]: Start isEmpty. Operand 118 states and 127 transitions. [2018-01-21 10:53:02,777 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 35 [2018-01-21 10:53:02,777 INFO L314 BasicCegarLoop]: Found error trace [2018-01-21 10:53:02,777 INFO L322 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-01-21 10:53:02,777 INFO L371 AbstractCegarLoop]: === Iteration 2 === [mainErr0EnsuresViolation]=== [2018-01-21 10:53:02,777 INFO L82 PathProgramCache]: Analyzing trace with hash -1359124646, now seen corresponding path program 1 times [2018-01-21 10:53:02,778 INFO L67 tionRefinementEngine]: Using refinement strategy TaipanRefinementStrategy [2018-01-21 10:53:02,778 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:02,778 INFO L101 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-01-21 10:53:02,779 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:02,779 INFO L280 anRefinementStrategy]: Using traceCheck mode SMTINTERPOL with AssertCodeBlockOrder NOT_INCREMENTALLY (IT: Craig_TreeInterpolation) [2018-01-21 10:53:02,789 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-01-21 10:53:02,790 WARN L137 erpolLogProxyWrapper]: Using partial proofs (cut at CNF-level). Set option :produce-proofs to true to get complete proofs. [2018-01-21 10:53:02,849 INFO L134 CoverageAnalysis]: Checked inductivity of 0 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-01-21 10:53:02,850 INFO L320 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-01-21 10:53:02,850 INFO L335 seRefinementStrategy]: Number of different interpolants: perfect sequences [5] imperfect sequences [] total 5 [2018-01-21 10:53:02,850 INFO L252 anRefinementStrategy]: Using the first perfect interpolant sequence [2018-01-21 10:53:02,851 INFO L409 AbstractCegarLoop]: Interpolant automaton has 5 states [2018-01-21 10:53:02,851 INFO L132 InterpolantAutomaton]: Constructing interpolant automaton starting with 5 interpolants. [2018-01-21 10:53:02,851 INFO L133 InterpolantAutomaton]: CoverageRelationStatistics Valid=7, Invalid=13, Unknown=0, NotChecked=0, Total=20 [2018-01-21 10:53:02,851 INFO L87 Difference]: Start difference. First operand 118 states and 127 transitions. Second operand 5 states. [2018-01-21 10:53:02,977 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-01-21 10:53:02,978 INFO L93 Difference]: Finished difference Result 276 states and 298 transitions. [2018-01-21 10:53:02,978 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 6 states. [2018-01-21 10:53:02,978 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 34 [2018-01-21 10:53:02,979 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-01-21 10:53:02,980 INFO L225 Difference]: With dead ends: 276 [2018-01-21 10:53:02,980 INFO L226 Difference]: Without dead ends: 186 [2018-01-21 10:53:02,981 INFO L525 BasicCegarLoop]: 0 DeclaredPredicates, 7 GetRequests, 2 SyntacticMatches, 0 SemanticMatches, 5 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=17, Invalid=25, Unknown=0, NotChecked=0, Total=42 [2018-01-21 10:53:02,982 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 186 states. [2018-01-21 10:53:02,989 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 186 to 122. [2018-01-21 10:53:02,990 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 122 states. [2018-01-21 10:53:02,990 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 122 states to 122 states and 131 transitions. [2018-01-21 10:53:02,991 INFO L78 Accepts]: Start accepts. Automaton has 122 states and 131 transitions. Word has length 34 [2018-01-21 10:53:02,991 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-01-21 10:53:02,991 INFO L432 AbstractCegarLoop]: Abstraction has 122 states and 131 transitions. [2018-01-21 10:53:02,991 INFO L433 AbstractCegarLoop]: Interpolant automaton has 5 states. [2018-01-21 10:53:02,991 INFO L276 IsEmpty]: Start isEmpty. Operand 122 states and 131 transitions. [2018-01-21 10:53:02,993 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 37 [2018-01-21 10:53:02,993 INFO L314 BasicCegarLoop]: Found error trace [2018-01-21 10:53:02,993 INFO L322 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-01-21 10:53:02,993 INFO L371 AbstractCegarLoop]: === Iteration 3 === [mainErr0EnsuresViolation]=== [2018-01-21 10:53:02,994 INFO L82 PathProgramCache]: Analyzing trace with hash -166833059, now seen corresponding path program 1 times [2018-01-21 10:53:02,994 INFO L67 tionRefinementEngine]: Using refinement strategy TaipanRefinementStrategy [2018-01-21 10:53:02,995 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:02,995 INFO L101 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-01-21 10:53:02,995 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:02,996 INFO L280 anRefinementStrategy]: Using traceCheck mode SMTINTERPOL with AssertCodeBlockOrder NOT_INCREMENTALLY (IT: Craig_TreeInterpolation) [2018-01-21 10:53:03,007 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-01-21 10:53:03,008 WARN L137 erpolLogProxyWrapper]: Using partial proofs (cut at CNF-level). Set option :produce-proofs to true to get complete proofs. [2018-01-21 10:53:03,086 INFO L134 CoverageAnalysis]: Checked inductivity of 0 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-01-21 10:53:03,087 INFO L320 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-01-21 10:53:03,087 INFO L335 seRefinementStrategy]: Number of different interpolants: perfect sequences [5] imperfect sequences [] total 5 [2018-01-21 10:53:03,087 INFO L252 anRefinementStrategy]: Using the first perfect interpolant sequence [2018-01-21 10:53:03,087 INFO L409 AbstractCegarLoop]: Interpolant automaton has 5 states [2018-01-21 10:53:03,088 INFO L132 InterpolantAutomaton]: Constructing interpolant automaton starting with 5 interpolants. [2018-01-21 10:53:03,088 INFO L133 InterpolantAutomaton]: CoverageRelationStatistics Valid=7, Invalid=13, Unknown=0, NotChecked=0, Total=20 [2018-01-21 10:53:03,088 INFO L87 Difference]: Start difference. First operand 122 states and 131 transitions. Second operand 5 states. [2018-01-21 10:53:03,230 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-01-21 10:53:03,230 INFO L93 Difference]: Finished difference Result 202 states and 218 transitions. [2018-01-21 10:53:03,231 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 5 states. [2018-01-21 10:53:03,231 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 36 [2018-01-21 10:53:03,231 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-01-21 10:53:03,232 INFO L225 Difference]: With dead ends: 202 [2018-01-21 10:53:03,232 INFO L226 Difference]: Without dead ends: 177 [2018-01-21 10:53:03,233 INFO L525 BasicCegarLoop]: 0 DeclaredPredicates, 7 GetRequests, 2 SyntacticMatches, 0 SemanticMatches, 5 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=17, Invalid=25, Unknown=0, NotChecked=0, Total=42 [2018-01-21 10:53:03,233 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 177 states. [2018-01-21 10:53:03,240 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 177 to 126. [2018-01-21 10:53:03,240 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 126 states. [2018-01-21 10:53:03,241 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 126 states to 126 states and 135 transitions. [2018-01-21 10:53:03,242 INFO L78 Accepts]: Start accepts. Automaton has 126 states and 135 transitions. Word has length 36 [2018-01-21 10:53:03,242 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-01-21 10:53:03,242 INFO L432 AbstractCegarLoop]: Abstraction has 126 states and 135 transitions. [2018-01-21 10:53:03,242 INFO L433 AbstractCegarLoop]: Interpolant automaton has 5 states. [2018-01-21 10:53:03,242 INFO L276 IsEmpty]: Start isEmpty. Operand 126 states and 135 transitions. [2018-01-21 10:53:03,244 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 57 [2018-01-21 10:53:03,244 INFO L314 BasicCegarLoop]: Found error trace [2018-01-21 10:53:03,245 INFO L322 BasicCegarLoop]: trace histogram [2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-01-21 10:53:03,245 INFO L371 AbstractCegarLoop]: === Iteration 4 === [mainErr0EnsuresViolation]=== [2018-01-21 10:53:03,245 INFO L82 PathProgramCache]: Analyzing trace with hash -742743919, now seen corresponding path program 1 times [2018-01-21 10:53:03,245 INFO L67 tionRefinementEngine]: Using refinement strategy TaipanRefinementStrategy [2018-01-21 10:53:03,246 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:03,246 INFO L101 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-01-21 10:53:03,246 INFO L117 rtionOrderModulation]: Craig nested/tree interpolation forces the following order [2018-01-21 10:53:03,246 INFO L280 anRefinementStrategy]: Using traceCheck mode SMTINTERPOL with AssertCodeBlockOrder NOT_INCREMENTALLY (IT: Craig_TreeInterpolation) [2018-01-21 10:53:03,264 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-01-21 10:53:03,265 WARN L137 erpolLogProxyWrapper]: Using partial proofs (cut at CNF-level). Set option :produce-proofs to true to get complete proofs. [2018-01-21 10:53:03,460 INFO L134 CoverageAnalysis]: Checked inductivity of 4 backedges. 0 proven. 2 refuted. 0 times theorem prover too weak. 2 trivial. 0 not checked. [2018-01-21 10:53:03,461 INFO L308 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-01-21 10:53:03,461 INFO L187 anRefinementStrategy]: Switched to InterpolantGenerator mode ABSTRACT_INTERPRETATION [2018-01-21 10:53:03,462 INFO L199 CegarAbsIntRunner]: Running AI on error trace of length 57 with the following transitions: [2018-01-21 10:53:03,464 INFO L201 CegarAbsIntRunner]: [0], [1], [7], [8], [9], [13], [18], [22], [28], [31], [32], [46], [47], [48], [53], [54], [55], [61], [65], [71], [75], [77], [80], [169], [173], [178], [182], [190], [194], [196], [197], [198], [202], [206], [275], [280], [284], [290], [291], [297], [301], [303], [304], [305], [366], [368], [369], [370], [371], [375], [377], [378], [379], [380] [2018-01-21 10:53:03,513 INFO L147 AbstractInterpreter]: Using domain VPDomain [2018-01-21 10:53:03,513 INFO L101 FixpointEngine]: Starting fixpoint engine with domain VPDomain (maxUnwinding=3, maxParallelStates=2) [2018-01-21 10:53:21,779 INFO L262 AbstractInterpreter]: Error location(s) were unreachable [2018-01-21 10:53:21,781 INFO L268 AbstractInterpreter]: Visited 54 different actions 60 times. Merged at 4 different actions 4 times. Never widened. Found 2 fixpoints after 2 different actions. Largest state had 37 variables. [2018-01-21 10:53:21,815 INFO L395 sIntCurrentIteration]: Generating AbsInt predicates [2018-01-21 10:53:58,179 INFO L232 lantSequenceWeakener]: Weakened 30 states. On average, predicates are now at 61.81% of their original sizes. [2018-01-21 10:53:58,180 INFO L408 sIntCurrentIteration]: Unifying AI predicates [2018-01-21 10:53:58,294 WARN L1007 $PredicateComparison]: unable to prove that (let ((.cse57 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) c_main_~list~5.offset)) (.cse58 (select |c_old(#valid)| 0)) (.cse60 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse59 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (forall ((v_weq0_1 Int)) (let ((.cse6 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse0 (select .cse6 v_weq0_1))) (or (= .cse0 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse7 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse2 (select |c_old(#valid)| 0)) (.cse1 (select .cse7 c_main_~list~5.offset)) (.cse5 (select .cse7 v_weq0_1)) (.cse3 (select .cse6 c_main_~list~5.offset)) (.cse4 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse1 .cse2) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse0 .cse3) (= .cse4 .cse5) (= .cse2 .cse0) (= 0 .cse1) (= .cse5 |c_#NULL.offset|) (= .cse3 v_weq0_1) (= v_weq0_1 .cse4) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse15 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse14 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse9 (select |c_old(#valid)| 0)) (.cse10 (select .cse14 v_weq0_1)) (.cse8 (select .cse15 c_main_~list~5.offset)) (.cse13 (select .cse15 v_weq0_1)) (.cse11 (select .cse14 c_main_~list~5.offset)) (.cse12 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse8 .cse9) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse10 .cse11) (= .cse12 .cse13) (= .cse9 .cse10) (= 0 .cse8) (= .cse13 |c_#NULL.offset|) (= .cse11 v_weq0_1) (= v_weq0_1 .cse12) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)))) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (forall ((v_weq0_1 Int)) (or (not (= v_weq0_1 0)) (= (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)))) (not (= 0 c_main_~list~5.base)) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)))) (forall ((v_weq0_1 Int)) (let ((.cse17 (select |c_#valid| v_weq0_1)) (.cse16 (select |c_old(#valid)| v_weq0_1))) (or (= .cse16 .cse17) (let ((.cse19 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse20 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse25 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse18 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse21 (select .cse25 c_main_~list~5.offset)) (.cse22 (select |c_old(#valid)| 0)) (.cse24 (select .cse20 c_main_~list~5.offset)) (.cse23 (select .cse19 c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= v_weq0_1 c_main_~list~5.base) (= .cse16 .cse18) (= .cse18 |c_#NULL.offset|) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= .cse19 .cse20) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (= .cse17 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 1 .cse17) (= |c_#NULL.offset| |c_#NULL.base|) (= .cse21 .cse22) (= .cse23 .cse21) (not (= 0 |c_main_#t~malloc0.base|)) (= 0 .cse24) (= .cse22 .cse16) (= .cse24 .cse23) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse25 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= (select |c_#length| v_weq0_1) 8))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse29 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse26 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse27 (select .cse29 v_weq1_1))) (or (= (select .cse26 v_weq1_1) .cse27) (let ((.cse34 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse28 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse33 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse31 (select .cse33 c_main_~list~5.offset)) (.cse35 (select .cse28 v_weq1_1)) (.cse36 (select .cse34 v_weq1_1)) (.cse32 (select |c_old(#valid)| v_weq0_1)) (.cse39 (select |c_#valid| v_weq0_1)) (.cse37 (select .cse28 c_main_~list~5.offset)) (.cse30 (select |c_old(#valid)| 0)) (.cse38 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse40 (select .cse34 c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse28 .cse29) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= .cse30 .cse31) (= v_weq0_1 |c_main_#t~malloc0.base|) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse32 .cse27) (= .cse33 .cse34) (= .cse31 v_weq1_1) (= .cse35 |c_#NULL.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse36 .cse35) (= 0 .cse37) (= c_main_~list~5.offset 0) (= .cse38 .cse36) (= .cse39 (select |c_#valid| |c_main_#t~malloc0.base|)) (= .cse40 |c_#NULL.base|) (= .cse26 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= (select .cse29 c_main_~list~5.offset) .cse32) (= 1 .cse39) (= |c_main_#t~malloc0.offset| (select .cse33 v_weq1_1)) (= .cse37 .cse30) (= v_weq1_1 .cse38) (= .cse27 .cse40) (= (select |c_#length| v_weq0_1) 8)))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse48 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse47 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse42 (select |c_old(#valid)| 0)) (.cse43 (select .cse47 v_weq0_1)) (.cse41 (select .cse48 c_main_~list~5.offset)) (.cse46 (select .cse48 v_weq0_1)) (.cse44 (select .cse47 c_main_~list~5.offset)) (.cse45 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse41 .cse42) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse43 .cse44) (= .cse45 .cse46) (= .cse42 .cse43) (= 0 .cse41) (= .cse46 |c_#NULL.offset|) (= .cse44 v_weq0_1) (= v_weq0_1 .cse45) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse56 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse55 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse50 (select |c_old(#valid)| 0)) (.cse51 (select .cse55 v_weq0_1)) (.cse49 (select .cse56 c_main_~list~5.offset)) (.cse54 (select .cse56 v_weq0_1)) (.cse52 (select .cse55 c_main_~list~5.offset)) (.cse53 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse49 .cse50) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse51 .cse52) (= .cse53 .cse54) (= .cse50 .cse51) (= 0 .cse49) (= .cse54 |c_#NULL.offset|) (= .cse52 v_weq0_1) (= v_weq0_1 .cse53) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))))) (= |c_#NULL.offset| |c_#NULL.base|) (= .cse57 .cse58) (= .cse59 .cse57) (not (= |c_#valid| |c_#length|)) (= .cse58 .cse60) (= |c_#NULL.base| c_main_~list~5.offset) (forall ((v_weq0_1 Int)) (let ((.cse68 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse66 (select .cse68 v_weq0_1))) (or (let ((.cse67 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse62 (select |c_old(#valid)| 0)) (.cse63 (select .cse67 v_weq0_1)) (.cse61 (select .cse68 c_main_~list~5.offset)) (.cse64 (select .cse67 c_main_~list~5.offset)) (.cse65 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse61 .cse62) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse63 .cse64) (= .cse65 .cse66) (= .cse62 .cse63) (= 0 .cse61) (= .cse66 |c_#NULL.offset|) (= .cse64 v_weq0_1) (= v_weq0_1 .cse65) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))) (= .cse66 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)))))) (forall ((v_weq0_1 Int)) (or (= (select |c_old(#valid)| v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse76 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse75 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse70 (select |c_old(#valid)| 0)) (.cse71 (select .cse75 v_weq0_1)) (.cse69 (select .cse76 c_main_~list~5.offset)) (.cse74 (select .cse76 v_weq0_1)) (.cse72 (select .cse75 c_main_~list~5.offset)) (.cse73 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse69 .cse70) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse71 .cse72) (= .cse73 .cse74) (= .cse70 .cse71) (= 0 .cse69) (= .cse74 |c_#NULL.offset|) (= .cse72 v_weq0_1) (= v_weq0_1 .cse73) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))))) (not (= |c_#length| |c_old(#valid)|)) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))) (= .cse60 |c_#NULL.offset|) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse86 (select |c_#memory_$Pointer$.base| v_weq0_1))) (let ((.cse78 (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (.cse77 (select .cse86 v_weq1_1))) (or (= .cse77 (select .cse78 v_weq1_1)) (let ((.cse80 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse79 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse85 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse82 (select .cse85 c_main_~list~5.offset)) (.cse87 (select .cse79 v_weq1_1)) (.cse83 (select |c_old(#valid)| v_weq0_1)) (.cse90 (select |c_#valid| v_weq0_1)) (.cse88 (select .cse79 c_main_~list~5.offset)) (.cse81 (select |c_old(#valid)| 0)) (.cse89 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse84 (select .cse80 v_weq1_1)) (.cse91 (select .cse86 c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse78) (= .cse79 .cse80) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= .cse81 .cse82) (= v_weq0_1 |c_main_#t~malloc0.base|) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse83 .cse84) (= .cse85 .cse86) (= .cse82 v_weq1_1) (= .cse87 |c_#NULL.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse77 .cse87) (= 0 .cse88) (= c_main_~list~5.offset 0) (= .cse89 .cse77) (= .cse90 (select |c_#valid| |c_main_#t~malloc0.base|)) (= .cse91 |c_#NULL.base|) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= (select .cse80 c_main_~list~5.offset) .cse83) (= 1 .cse90) (= |c_main_#t~malloc0.offset| (select .cse85 v_weq1_1)) (= .cse88 .cse81) (= v_weq1_1 .cse89) (= .cse84 .cse91) (= (select |c_#length| v_weq0_1) 8)))))))) (= 0 .cse59) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (or (not (= v_weq0_1 c_main_~list~5.base)) (not (= v_weq1_1 0)) (= (select (select |c_#memory_$Pointer$.base| v_weq0_1) v_weq1_1) (select (select |c_#memory_$Pointer$.offset| v_weq0_1) v_weq1_1)))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse99 (select |c_#memory_$Pointer$.base| v_weq0_1))) (let ((.cse106 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse101 (select .cse99 v_weq1_1))) (or (not (= v_weq0_1 c_main_~list~5.base)) (not (= v_weq1_1 0)) (let ((.cse93 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse92 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse98 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse95 (select .cse98 c_main_~list~5.offset)) (.cse100 (select .cse92 v_weq1_1)) (.cse96 (select |c_old(#valid)| v_weq0_1)) (.cse104 (select |c_#valid| v_weq0_1)) (.cse102 (select .cse92 c_main_~list~5.offset)) (.cse94 (select |c_old(#valid)| 0)) (.cse103 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse97 (select .cse93 v_weq1_1)) (.cse105 (select .cse99 c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse92 .cse93) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= .cse94 .cse95) (= v_weq0_1 |c_main_#t~malloc0.base|) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse96 .cse97) (= .cse98 .cse99) (= .cse95 v_weq1_1) (= .cse100 |c_#NULL.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse101 .cse100) (= 0 .cse102) (= c_main_~list~5.offset 0) (= .cse103 .cse101) (= .cse104 (select |c_#valid| |c_main_#t~malloc0.base|)) (= .cse105 |c_#NULL.base|) (= .cse106 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= (select .cse93 c_main_~list~5.offset) .cse96) (= 1 .cse104) (= |c_main_#t~malloc0.offset| (select .cse98 v_weq1_1)) (= .cse102 .cse94) (= v_weq1_1 .cse103) (= .cse97 .cse105) (= (select |c_#length| v_weq0_1) 8)))) (= (select .cse106 v_weq1_1) .cse101))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse122 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse107 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (or (not (= v_weq0_1 c_main_~list~5.base)) (not (= v_weq1_1 0)) (let ((.cse109 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse115 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse108 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse114 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse111 (select .cse114 c_main_~list~5.offset)) (.cse116 (select .cse108 v_weq1_1)) (.cse117 (select .cse115 v_weq1_1)) (.cse112 (select |c_old(#valid)| v_weq0_1)) (.cse120 (select |c_#valid| v_weq0_1)) (.cse118 (select .cse108 c_main_~list~5.offset)) (.cse110 (select |c_old(#valid)| 0)) (.cse119 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse113 (select .cse109 v_weq1_1)) (.cse121 (select .cse115 c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse107) (= .cse108 .cse109) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= .cse110 .cse111) (= v_weq0_1 |c_main_#t~malloc0.base|) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse112 .cse113) (= .cse114 .cse115) (= .cse111 v_weq1_1) (= .cse116 |c_#NULL.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse117 .cse116) (= 0 .cse118) (= c_main_~list~5.offset 0) (= .cse119 .cse117) (= .cse120 (select |c_#valid| |c_main_#t~malloc0.base|)) (= .cse121 |c_#NULL.base|) (= .cse122 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= (select .cse109 c_main_~list~5.offset) .cse112) (= 1 .cse120) (= |c_main_#t~malloc0.offset| (select .cse114 v_weq1_1)) (= .cse118 .cse110) (= v_weq1_1 .cse119) (= .cse113 .cse121) (= (select |c_#length| v_weq0_1) 8)))) (= (select .cse122 v_weq1_1) (select .cse107 v_weq1_1))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse126 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse124 (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (.cse123 (select .cse126 v_weq1_1))) (or (= .cse123 (select .cse124 v_weq1_1)) (not (= v_weq0_1 c_main_~list~5.base)) (not (= v_weq1_1 0)) (let ((.cse131 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse125 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse130 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse128 (select .cse130 c_main_~list~5.offset)) (.cse132 (select .cse125 v_weq1_1)) (.cse133 (select .cse131 v_weq1_1)) (.cse129 (select |c_old(#valid)| v_weq0_1)) (.cse136 (select |c_#valid| v_weq0_1)) (.cse134 (select .cse125 c_main_~list~5.offset)) (.cse127 (select |c_old(#valid)| 0)) (.cse135 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse137 (select .cse131 c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse124) (= .cse125 .cse126) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= .cse127 .cse128) (= v_weq0_1 |c_main_#t~malloc0.base|) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse129 .cse123) (= .cse130 .cse131) (= .cse128 v_weq1_1) (= .cse132 |c_#NULL.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse133 .cse132) (= 0 .cse134) (= c_main_~list~5.offset 0) (= .cse135 .cse133) (= .cse136 (select |c_#valid| |c_main_#t~malloc0.base|)) (= .cse137 |c_#NULL.base|) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= (select .cse126 c_main_~list~5.offset) .cse129) (= 1 .cse136) (= |c_main_#t~malloc0.offset| (select .cse130 v_weq1_1)) (= .cse134 .cse127) (= v_weq1_1 .cse135) (= .cse123 .cse137) (= (select |c_#length| v_weq0_1) 8)))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))) (forall ((v_weq0_1 Int)) (or (not (= v_weq0_1 0)) (let ((.cse145 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse144 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse139 (select |c_old(#valid)| 0)) (.cse140 (select .cse144 v_weq0_1)) (.cse138 (select .cse145 c_main_~list~5.offset)) (.cse143 (select .cse145 v_weq0_1)) (.cse141 (select .cse144 c_main_~list~5.offset)) (.cse142 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse138 .cse139) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse140 .cse141) (= .cse142 .cse143) (= .cse139 .cse140) (= 0 .cse138) (= .cse143 |c_#NULL.offset|) (= .cse141 v_weq0_1) (= v_weq0_1 .cse142) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)))) (forall ((v_weq0_1 Int)) (let ((.cse153 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse146 (select .cse153 v_weq0_1))) (or (= .cse146 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse152 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse148 (select |c_old(#valid)| 0)) (.cse149 (select .cse152 v_weq0_1)) (.cse147 (select .cse153 c_main_~list~5.offset)) (.cse150 (select .cse152 c_main_~list~5.offset)) (.cse151 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse147 .cse148) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse149 .cse150) (= .cse151 .cse146) (= .cse148 .cse149) (= 0 .cse147) (= .cse146 |c_#NULL.offset|) (= .cse150 v_weq0_1) (= v_weq0_1 .cse151) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))))))) (forall ((v_weq0_1 Int)) (let ((.cse160 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse154 (select .cse160 v_weq0_1))) (or (= .cse154 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1)) (let ((.cse161 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse156 (select |c_old(#valid)| 0)) (.cse155 (select .cse161 c_main_~list~5.offset)) (.cse159 (select .cse161 v_weq0_1)) (.cse157 (select .cse160 c_main_~list~5.offset)) (.cse158 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse155 .cse156) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse154 .cse157) (= .cse158 .cse159) (= .cse156 .cse154) (= 0 .cse155) (= .cse159 |c_#NULL.offset|) (= .cse157 v_weq0_1) (= v_weq0_1 .cse158) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))))))) (forall ((v_weq0_1 Int)) (let ((.cse162 (select |c_#length| v_weq0_1))) (or (= .cse162 (select |c_old(#length)| v_weq0_1)) (let ((.cse165 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse166 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse172 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse164 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse167 (select |c_#valid| v_weq0_1)) (.cse168 (select .cse172 c_main_~list~5.offset)) (.cse169 (select |c_old(#valid)| 0)) (.cse163 (select |c_old(#valid)| v_weq0_1)) (.cse171 (select .cse166 c_main_~list~5.offset)) (.cse170 (select .cse165 c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= v_weq0_1 c_main_~list~5.base) (= .cse163 .cse164) (= .cse164 |c_#NULL.offset|) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= .cse165 .cse166) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (= .cse167 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 1 .cse167) (= |c_#NULL.offset| |c_#NULL.base|) (= .cse168 .cse169) (= .cse170 .cse168) (not (= 0 |c_main_#t~malloc0.base|)) (= 0 .cse171) (= .cse169 .cse163) (= .cse171 .cse170) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse172 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= .cse162 8))))))) (= 1 (select |c_#valid| |c_main_#t~malloc0.base|)) (not (= |c_#valid| |c_old(#valid)|)))) is different from false [2018-01-21 10:53:58,337 WARN L1007 $PredicateComparison]: unable to prove that (let ((.cse73 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) c_main_~list~5.offset)) (.cse74 (select |c_old(#valid)| 0)) (.cse84 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse75 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (forall ((v_weq0_1 Int)) (let ((.cse6 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse0 (select .cse6 v_weq0_1))) (or (= .cse0 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse7 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse2 (select |c_old(#valid)| 0)) (.cse1 (select .cse7 c_main_~list~5.offset)) (.cse5 (select .cse7 v_weq0_1)) (.cse3 (select .cse6 c_main_~list~5.offset)) (.cse4 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse1 .cse2) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse0 .cse3) (= .cse4 .cse5) (= .cse2 .cse0) (= 0 .cse1) (= .cse5 |c_#NULL.offset|) (= .cse3 v_weq0_1) (= v_weq0_1 .cse4) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse15 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse14 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse9 (select |c_old(#valid)| 0)) (.cse10 (select .cse14 v_weq0_1)) (.cse8 (select .cse15 c_main_~list~5.offset)) (.cse13 (select .cse15 v_weq0_1)) (.cse11 (select .cse14 c_main_~list~5.offset)) (.cse12 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse8 .cse9) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse10 .cse11) (= .cse12 .cse13) (= .cse9 .cse10) (= 0 .cse8) (= .cse13 |c_#NULL.offset|) (= .cse11 v_weq0_1) (= v_weq0_1 .cse12) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)))) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (forall ((v_weq0_1 Int)) (or (not (= v_weq0_1 0)) (= (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)))) (not (= 0 c_main_~list~5.base)) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)))) (forall ((v_weq0_1 Int)) (let ((.cse17 (select |c_#valid| v_weq0_1)) (.cse16 (select |c_old(#valid)| v_weq0_1))) (or (= .cse16 .cse17) (let ((.cse19 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse20 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse25 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse18 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse21 (select .cse25 c_main_~list~5.offset)) (.cse22 (select |c_old(#valid)| 0)) (.cse24 (select .cse20 c_main_~list~5.offset)) (.cse23 (select .cse19 c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= v_weq0_1 c_main_~list~5.base) (= .cse16 .cse18) (= .cse18 |c_#NULL.offset|) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= .cse19 .cse20) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (= .cse17 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 1 .cse17) (= |c_#NULL.offset| |c_#NULL.base|) (= .cse21 .cse22) (= .cse23 .cse21) (not (= 0 |c_main_#t~malloc0.base|)) (= 0 .cse24) (= .cse22 .cse16) (= .cse24 .cse23) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse25 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= (select |c_#length| v_weq0_1) 8))))))) (forall ((v_weq0_1 Int)) (let ((.cse32 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse28 (select .cse32 v_weq0_1))) (or (let ((.cse33 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse27 (select |c_old(#valid)| 0)) (.cse26 (select .cse33 c_main_~list~5.offset)) (.cse30 (select .cse33 v_weq0_1)) (.cse29 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse31 (select .cse32 c_main_~list~5.offset))) (and (= .cse26 .cse27) (= .cse28 v_weq0_1) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse29 .cse30) (= .cse27 .cse31) (= 0 .cse26) (= .cse30 |c_#NULL.offset|) (= v_weq0_1 .cse29) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base)) (= .cse31 .cse28)))) (= .cse28 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse37 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse34 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse35 (select .cse37 v_weq1_1))) (or (= (select .cse34 v_weq1_1) .cse35) (let ((.cse42 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse36 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse41 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse39 (select .cse41 c_main_~list~5.offset)) (.cse43 (select .cse36 v_weq1_1)) (.cse44 (select .cse42 v_weq1_1)) (.cse40 (select |c_old(#valid)| v_weq0_1)) (.cse47 (select |c_#valid| v_weq0_1)) (.cse45 (select .cse36 c_main_~list~5.offset)) (.cse38 (select |c_old(#valid)| 0)) (.cse46 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse48 (select .cse42 c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse36 .cse37) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= .cse38 .cse39) (= v_weq0_1 |c_main_#t~malloc0.base|) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse40 .cse35) (= .cse41 .cse42) (= .cse39 v_weq1_1) (= .cse43 |c_#NULL.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse44 .cse43) (= 0 .cse45) (= c_main_~list~5.offset 0) (= .cse46 .cse44) (= .cse47 (select |c_#valid| |c_main_#t~malloc0.base|)) (= .cse48 |c_#NULL.base|) (= .cse34 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= (select .cse37 c_main_~list~5.offset) .cse40) (= 1 .cse47) (= |c_main_#t~malloc0.offset| (select .cse41 v_weq1_1)) (= .cse45 .cse38) (= v_weq1_1 .cse46) (= .cse35 .cse48) (= (select |c_#length| v_weq0_1) 8)))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse56 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse55 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse50 (select |c_old(#valid)| 0)) (.cse51 (select .cse55 v_weq0_1)) (.cse49 (select .cse56 c_main_~list~5.offset)) (.cse54 (select .cse56 v_weq0_1)) (.cse52 (select .cse55 c_main_~list~5.offset)) (.cse53 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse49 .cse50) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse51 .cse52) (= .cse53 .cse54) (= .cse50 .cse51) (= 0 .cse49) (= .cse54 |c_#NULL.offset|) (= .cse52 v_weq0_1) (= v_weq0_1 .cse53) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))))) (forall ((v_weq0_1 Int)) (let ((.cse64 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse61 (select .cse64 v_weq0_1))) (or (let ((.cse63 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse58 (select |c_old(#valid)| 0)) (.cse57 (select .cse64 c_main_~list~5.offset)) (.cse60 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse62 (select .cse63 c_main_~list~5.offset)) (.cse59 (select .cse63 v_weq0_1))) (and (= .cse57 .cse58) (= .cse59 v_weq0_1) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse60 .cse61) (= .cse58 .cse62) (= 0 .cse57) (= .cse61 |c_#NULL.offset|) (= v_weq0_1 .cse60) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base)) (= .cse62 .cse59)))) (= .cse61 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse72 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse71 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse66 (select |c_old(#valid)| 0)) (.cse67 (select .cse71 v_weq0_1)) (.cse65 (select .cse72 c_main_~list~5.offset)) (.cse70 (select .cse72 v_weq0_1)) (.cse68 (select .cse71 c_main_~list~5.offset)) (.cse69 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse65 .cse66) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse67 .cse68) (= .cse69 .cse70) (= .cse66 .cse67) (= 0 .cse65) (= .cse70 |c_#NULL.offset|) (= .cse68 v_weq0_1) (= v_weq0_1 .cse69) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))))) (= |c_#NULL.offset| |c_#NULL.base|) (= .cse73 .cse74) (= .cse75 .cse73) (forall ((v_weq0_1 Int)) (let ((.cse83 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse80 (select .cse83 v_weq0_1))) (or (let ((.cse82 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse77 (select |c_old(#valid)| 0)) (.cse76 (select .cse83 c_main_~list~5.offset)) (.cse79 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse81 (select .cse82 c_main_~list~5.offset)) (.cse78 (select .cse82 v_weq0_1))) (and (= .cse76 .cse77) (= .cse78 v_weq0_1) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse79 .cse80) (= .cse77 .cse81) (= 0 .cse76) (= .cse80 |c_#NULL.offset|) (= v_weq0_1 .cse79) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base)) (= .cse81 .cse78)))) (= .cse80 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)))))) (not (= |c_#valid| |c_#length|)) (= .cse74 .cse84) (= |c_#NULL.base| c_main_~list~5.offset) (forall ((v_weq0_1 Int)) (or (= (select |c_old(#valid)| v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse92 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse91 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse86 (select |c_old(#valid)| 0)) (.cse87 (select .cse91 v_weq0_1)) (.cse85 (select .cse92 c_main_~list~5.offset)) (.cse90 (select .cse92 v_weq0_1)) (.cse88 (select .cse91 c_main_~list~5.offset)) (.cse89 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse85 .cse86) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse87 .cse88) (= .cse89 .cse90) (= .cse86 .cse87) (= 0 .cse85) (= .cse90 |c_#NULL.offset|) (= .cse88 v_weq0_1) (= v_weq0_1 .cse89) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))))) (not (= |c_#length| |c_old(#valid)|)) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse94 (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (.cse93 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1))) (or (not (= v_weq0_1 c_main_~list~5.base)) (not (= v_weq1_1 0)) (= (select .cse93 v_weq1_1) (select .cse94 v_weq1_1)) (let ((.cse97 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse96 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse105 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse106 (select |c_#memory_$Pointer$.base| v_weq0_1))) (let ((.cse98 (select .cse106 v_weq1_1)) (.cse101 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse100 (select .cse105 c_main_~list~5.offset)) (.cse102 (select .cse96 v_weq1_1)) (.cse103 (select |c_old(#valid)| v_weq0_1)) (.cse108 (select |c_#valid| v_weq0_1)) (.cse107 (select .cse96 c_main_~list~5.offset)) (.cse99 (select |c_old(#valid)| 0)) (.cse95 (select .cse105 v_weq1_1)) (.cse104 (select .cse97 v_weq1_1)) (.cse109 (select .cse106 c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse94) (= |c_#NULL.offset| .cse95) (= .cse96 .cse97) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= v_weq1_1 .cse98) (= .cse99 .cse100) (= .cse98 .cse101) (= v_weq0_1 |c_main_#t~malloc0.base|) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse101 .cse102) (= .cse103 .cse104) (= .cse105 .cse106) (= .cse100 v_weq1_1) (= .cse102 |c_#NULL.offset|) (= 0 .cse107) (= c_main_~list~5.offset 0) (= .cse108 (select |c_#valid| |c_main_#t~malloc0.base|)) (= .cse109 |c_#NULL.base|) (= .cse93 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= (select .cse97 c_main_~list~5.offset) .cse103) (= 1 .cse108) (= .cse107 .cse99) (= .cse95 |c_main_#t~malloc0.offset|) (= .cse104 .cse109) (= (select |c_#length| v_weq0_1) 8))))))) (= .cse84 |c_#NULL.offset|) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse119 (select |c_#memory_$Pointer$.base| v_weq0_1))) (let ((.cse111 (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (.cse110 (select .cse119 v_weq1_1))) (or (= .cse110 (select .cse111 v_weq1_1)) (let ((.cse113 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse112 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse118 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse115 (select .cse118 c_main_~list~5.offset)) (.cse120 (select .cse112 v_weq1_1)) (.cse116 (select |c_old(#valid)| v_weq0_1)) (.cse123 (select |c_#valid| v_weq0_1)) (.cse121 (select .cse112 c_main_~list~5.offset)) (.cse114 (select |c_old(#valid)| 0)) (.cse122 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse117 (select .cse113 v_weq1_1)) (.cse124 (select .cse119 c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse111) (= .cse112 .cse113) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= .cse114 .cse115) (= v_weq0_1 |c_main_#t~malloc0.base|) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse116 .cse117) (= .cse118 .cse119) (= .cse115 v_weq1_1) (= .cse120 |c_#NULL.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse110 .cse120) (= 0 .cse121) (= c_main_~list~5.offset 0) (= .cse122 .cse110) (= .cse123 (select |c_#valid| |c_main_#t~malloc0.base|)) (= .cse124 |c_#NULL.base|) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= (select .cse113 c_main_~list~5.offset) .cse116) (= 1 .cse123) (= |c_main_#t~malloc0.offset| (select .cse118 v_weq1_1)) (= .cse121 .cse114) (= v_weq1_1 .cse122) (= .cse117 .cse124) (= (select |c_#length| v_weq0_1) 8)))))))) (= 0 .cse75) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (or (not (= v_weq0_1 c_main_~list~5.base)) (not (= v_weq1_1 0)) (= (select (select |c_#memory_$Pointer$.base| v_weq0_1) v_weq1_1) (select (select |c_#memory_$Pointer$.offset| v_weq0_1) v_weq1_1)))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse128 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse126 (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (.cse125 (select .cse128 v_weq1_1))) (or (= .cse125 (select .cse126 v_weq1_1)) (not (= v_weq0_1 c_main_~list~5.base)) (not (= v_weq1_1 0)) (let ((.cse133 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse127 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse132 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse130 (select .cse132 c_main_~list~5.offset)) (.cse134 (select .cse127 v_weq1_1)) (.cse135 (select .cse133 v_weq1_1)) (.cse131 (select |c_old(#valid)| v_weq0_1)) (.cse138 (select |c_#valid| v_weq0_1)) (.cse136 (select .cse127 c_main_~list~5.offset)) (.cse129 (select |c_old(#valid)| 0)) (.cse137 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse139 (select .cse133 c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse126) (= .cse127 .cse128) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= .cse129 .cse130) (= v_weq0_1 |c_main_#t~malloc0.base|) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse131 .cse125) (= .cse132 .cse133) (= .cse130 v_weq1_1) (= .cse134 |c_#NULL.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse135 .cse134) (= 0 .cse136) (= c_main_~list~5.offset 0) (= .cse137 .cse135) (= .cse138 (select |c_#valid| |c_main_#t~malloc0.base|)) (= .cse139 |c_#NULL.base|) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= (select .cse128 c_main_~list~5.offset) .cse131) (= 1 .cse138) (= |c_main_#t~malloc0.offset| (select .cse132 v_weq1_1)) (= .cse136 .cse129) (= v_weq1_1 .cse137) (= .cse125 .cse139) (= (select |c_#length| v_weq0_1) 8)))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))) (forall ((v_weq0_1 Int)) (or (not (= v_weq0_1 0)) (let ((.cse147 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse146 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse141 (select |c_old(#valid)| 0)) (.cse142 (select .cse146 v_weq0_1)) (.cse140 (select .cse147 c_main_~list~5.offset)) (.cse145 (select .cse147 v_weq0_1)) (.cse143 (select .cse146 c_main_~list~5.offset)) (.cse144 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= .cse140 .cse141) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse142 .cse143) (= .cse144 .cse145) (= .cse141 .cse142) (= 0 .cse140) (= .cse145 |c_#NULL.offset|) (= .cse143 v_weq0_1) (= v_weq0_1 .cse144) (= c_main_~list~5.offset 0) (= |c_#NULL.base| c_main_~list~5.offset) (not (= 0 c_main_~list~5.base))))) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse159 (select |c_#memory_$Pointer$.base| v_weq0_1))) (let ((.cse163 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse151 (select .cse159 v_weq1_1))) (or (not (= v_weq0_1 c_main_~list~5.base)) (not (= v_weq1_1 0)) (let ((.cse150 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse149 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse158 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse154 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse153 (select .cse158 c_main_~list~5.offset)) (.cse155 (select .cse149 v_weq1_1)) (.cse156 (select |c_old(#valid)| v_weq0_1)) (.cse161 (select |c_#valid| v_weq0_1)) (.cse160 (select .cse149 c_main_~list~5.offset)) (.cse152 (select |c_old(#valid)| 0)) (.cse148 (select .cse158 v_weq1_1)) (.cse157 (select .cse150 v_weq1_1)) (.cse162 (select .cse159 c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= |c_#NULL.offset| .cse148) (= .cse149 .cse150) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= v_weq1_1 .cse151) (= .cse152 .cse153) (= .cse151 .cse154) (= v_weq0_1 |c_main_#t~malloc0.base|) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse154 .cse155) (= .cse156 .cse157) (= .cse158 .cse159) (= .cse153 v_weq1_1) (= .cse155 |c_#NULL.offset|) (= 0 .cse160) (= c_main_~list~5.offset 0) (= .cse161 (select |c_#valid| |c_main_#t~malloc0.base|)) (= .cse162 |c_#NULL.base|) (= .cse163 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= (select .cse150 c_main_~list~5.offset) .cse156) (= 1 .cse161) (= .cse160 .cse152) (= .cse148 |c_main_#t~malloc0.offset|) (= .cse157 .cse162) (= (select |c_#length| v_weq0_1) 8)))) (= (select .cse163 v_weq1_1) .cse151))))) (forall ((v_weq0_1 Int)) (let ((.cse164 (select |c_#length| v_weq0_1))) (or (= .cse164 (select |c_old(#length)| v_weq0_1)) (let ((.cse167 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse168 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse174 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse166 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse169 (select |c_#valid| v_weq0_1)) (.cse170 (select .cse174 c_main_~list~5.offset)) (.cse171 (select |c_old(#valid)| 0)) (.cse165 (select |c_old(#valid)| v_weq0_1)) (.cse173 (select .cse168 c_main_~list~5.offset)) (.cse172 (select .cse167 c_main_~list~5.offset))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= v_weq0_1 c_main_~list~5.base) (= .cse165 .cse166) (= .cse166 |c_#NULL.offset|) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= .cse167 .cse168) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (= .cse169 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 1 .cse169) (= |c_#NULL.offset| |c_#NULL.base|) (= .cse170 .cse171) (= .cse172 .cse170) (not (= 0 |c_main_#t~malloc0.base|)) (= 0 .cse173) (= .cse171 .cse165) (= .cse173 .cse172) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse174 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= .cse164 8))))))) (= 1 (select |c_#valid| |c_main_#t~malloc0.base|)) (not (= |c_#valid| |c_old(#valid)|)))) is different from false [2018-01-21 10:54:00,407 WARN L1007 $PredicateComparison]: unable to prove that (let ((.cse324 (+ c_main_~list~5.offset 4))) (let ((.cse16 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse324)) (.cse300 (select |c_old(#valid)| 0)) (.cse301 (select |c_#valid| c_main_~list~5.offset)) (.cse323 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse324)) (.cse302 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (or (not (= v_weq0_1 c_main_~list~5.base)) (and (not (= v_weq1_1 (+ c_main_~list~5.offset 4))) (not (= v_weq1_1 0))) (= (select (select |c_#memory_$Pointer$.base| v_weq0_1) v_weq1_1) (select (select |c_#memory_$Pointer$.offset| v_weq0_1) v_weq1_1)))) (not (= 0 c_main_~list~5.base)) (forall ((v_weq0_1 Int)) (let ((.cse8 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse0 (select .cse8 v_weq0_1))) (or (= .cse0 (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse4 (+ c_main_~list~5.offset 4)) (.cse9 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse1 (select |c_old(#valid)| 0)) (.cse2 (select .cse9 v_weq0_1)) (.cse6 (select .cse9 .cse4)) (.cse3 (select |c_#valid| c_main_~list~5.offset)) (.cse7 (select .cse8 .cse4)) (.cse5 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse1 .cse0) (= .cse2 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse0 .cse3) (= .cse4 v_weq0_1) (= 0 .cse1) (= .cse5 .cse2) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse6 0) (= c_main_~list~5.offset .cse6) (= .cse3 .cse7) (= .cse7 .cse5)))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)) (let ((.cse15 (+ c_main_~list~5.offset 4))) (let ((.cse11 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse10 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse15)) (.cse13 (select |c_#valid| c_main_~list~5.offset)) (.cse14 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse15)) (.cse12 (select |c_old(#valid)| 0))) (and (= .cse10 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse11 |c_#NULL.base|) (not (= c_main_~list~5.base 0)) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse11) (= .cse12 .cse13) (not (= 0 c_main_~list~5.base)) (= |c_#NULL.offset| .cse10) (= .cse14 v_weq0_1) (= .cse13 .cse14) (= 0 .cse12)))) (not (= v_weq0_1 0)))) (= .cse16 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse41 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse36 (+ c_main_~list~5.offset 4))) (let ((.cse39 (select .cse41 .cse36)) (.cse44 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse27 (select |c_old(#valid)| v_weq0_1)) (.cse43 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse46 (select |c_#valid| v_weq0_1)) (.cse47 (select |c_old(#valid)| 0)) (.cse45 (select |c_#valid| c_main_~list~5.offset)) (.cse42 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse40 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse17 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse18 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse20 (= .cse42 .cse40)) (.cse30 (= .cse47 .cse45)) (.cse21 (not (= 0 c_main_~list~5.base))) (.cse31 (= .cse46 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse32 (= .cse43 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse33 (= 0 .cse47)) (.cse34 (= 1 .cse46)) (.cse22 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse35 (= (select .cse40 .cse36) .cse27)) (.cse24 (select .cse42 .cse36)) (.cse23 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse25 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse29 (= .cse41 .cse44)) (.cse37 (= .cse45 .cse39)) (.cse38 (= (select |c_#length| v_weq0_1) 8))) (or (let ((.cse26 (select .cse42 v_weq1_1)) (.cse19 (select .cse41 v_weq1_1)) (.cse28 (select .cse40 v_weq1_1))) (and .cse17 .cse18 (= |c_#NULL.offset| .cse19) .cse20 .cse21 .cse22 .cse23 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse24 0) (= .cse25 .cse26) (= .cse27 .cse28) .cse29 (= c_main_~list~5.offset .cse24) (= .cse26 |c_#NULL.offset|) .cse30 .cse31 .cse32 .cse33 .cse34 .cse35 (= .cse19 |c_main_#t~malloc0.offset|) (= .cse28 |c_#NULL.base|) (= .cse36 v_weq1_1) .cse37 .cse38 (= .cse39 .cse25))) (not (= v_weq0_1 c_main_~list~5.base)) (and .cse17 .cse18 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse25 |c_#NULL.offset|) .cse20 (= c_main_~list~5.offset 0) .cse30 .cse21 .cse31 .cse32 .cse33 .cse34 .cse22 .cse35 (= .cse24 c_main_~list~5.offset) (= |c_#NULL.base| .cse24) .cse23 (= v_weq1_1 .cse25) (= .cse27 |c_#NULL.base|) .cse29 (= .cse39 v_weq1_1) .cse37 .cse38) (and (not (= v_weq1_1 .cse36)) (not (= v_weq1_1 0))) (= (select .cse43 v_weq1_1) (select .cse44 v_weq1_1))))))) (forall ((v_weq0_1 Int)) (let ((.cse49 (select |c_#valid| v_weq0_1)) (.cse48 (select |c_old(#valid)| v_weq0_1))) (or (= .cse48 .cse49) (let ((.cse57 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse51 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse55 (+ c_main_~list~5.offset 4))) (let ((.cse53 (select |c_old(#valid)| 0)) (.cse52 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse56 (select .cse51 .cse55)) (.cse54 (select |c_#valid| c_main_~list~5.offset)) (.cse58 (select .cse57 .cse55)) (.cse50 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= v_weq0_1 c_main_~list~5.base) (= .cse50 |c_#NULL.offset|) (= .cse51 .cse52) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (= c_main_~list~5.offset 0) (= .cse53 .cse54) (= .cse49 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 0 .cse53) (= 1 .cse49) (= (select .cse52 .cse55) .cse48) (= .cse56 c_main_~list~5.offset) (= |c_#NULL.base| .cse56) (not (= 0 |c_main_#t~malloc0.base|)) (= .cse48 |c_#NULL.base|) (= .cse57 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= .cse54 .cse58) (= (select |c_#length| v_weq0_1) 8) (= .cse58 .cse50))))))) (forall ((v_weq0_1 Int)) (let ((.cse71 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse70 (+ c_main_~list~5.offset 4))) (let ((.cse63 (select |c_#valid| c_main_~list~5.offset)) (.cse65 (select .cse71 .cse70)) (.cse72 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse62 (select |c_old(#valid)| 0))) (let ((.cse61 (not (= c_main_~list~5.base 0))) (.cse64 (not (= 0 c_main_~list~5.base))) (.cse67 (= 0 .cse62)) (.cse59 (select .cse72 .cse70)) (.cse66 (= .cse63 .cse65)) (.cse60 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse69 (select .cse72 v_weq0_1))) (or (and (= .cse59 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse60 |c_#NULL.base|) .cse61 (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse60) (= .cse62 .cse63) .cse64 (= |c_#NULL.offset| .cse59) (= .cse65 v_weq0_1) .cse66 .cse67) (let ((.cse68 (select .cse71 v_weq0_1))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse61 (= .cse62 .cse68) (= .cse69 |c_#NULL.offset|) .cse64 (= .cse68 .cse63) (= .cse70 v_weq0_1) .cse67 (= .cse60 .cse69) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse59 0) (= c_main_~list~5.offset .cse59) .cse66 (= .cse65 .cse60))) (= .cse69 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (let ((.cse78 (+ c_main_~list~5.offset 4))) (let ((.cse74 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse73 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse78)) (.cse76 (select |c_#valid| c_main_~list~5.offset)) (.cse77 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse78)) (.cse75 (select |c_old(#valid)| 0))) (and (= .cse73 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse74 |c_#NULL.base|) (not (= c_main_~list~5.base 0)) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse74) (= .cse75 .cse76) (not (= 0 c_main_~list~5.base)) (= |c_#NULL.offset| .cse73) (= .cse77 v_weq0_1) (= .cse76 .cse77) (= 0 .cse75)))) (not (= v_weq0_1 0)))) (forall ((v_weq0_1 Int)) (let ((.cse79 (select |c_#length| v_weq0_1))) (or (= .cse79 (select |c_old(#length)| v_weq0_1)) (let ((.cse89 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse81 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse86 (+ c_main_~list~5.offset 4))) (let ((.cse83 (select |c_old(#valid)| 0)) (.cse85 (select |c_#valid| v_weq0_1)) (.cse82 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse88 (select .cse81 .cse86)) (.cse87 (select |c_old(#valid)| v_weq0_1)) (.cse84 (select |c_#valid| c_main_~list~5.offset)) (.cse90 (select .cse89 .cse86)) (.cse80 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= v_weq0_1 c_main_~list~5.base) (= .cse80 |c_#NULL.offset|) (= .cse81 .cse82) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (= c_main_~list~5.offset 0) (= .cse83 .cse84) (= .cse85 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 0 .cse83) (= 1 .cse85) (= (select .cse82 .cse86) .cse87) (= .cse88 c_main_~list~5.offset) (= |c_#NULL.base| .cse88) (not (= 0 |c_main_#t~malloc0.base|)) (= .cse87 |c_#NULL.base|) (= .cse89 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= .cse84 .cse90) (= .cse79 8) (= .cse90 .cse80))))))) (forall ((v_weq0_1 Int)) (let ((.cse99 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse91 (select .cse99 v_weq0_1))) (or (= .cse91 (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse95 (+ c_main_~list~5.offset 4)) (.cse100 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse92 (select |c_old(#valid)| 0)) (.cse93 (select .cse100 v_weq0_1)) (.cse97 (select .cse100 .cse95)) (.cse94 (select |c_#valid| c_main_~list~5.offset)) (.cse98 (select .cse99 .cse95)) (.cse96 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse92 .cse91) (= .cse93 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse91 .cse94) (= .cse95 v_weq0_1) (= 0 .cse92) (= .cse96 .cse93) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse97 0) (= c_main_~list~5.offset .cse97) (= .cse94 .cse98) (= .cse98 .cse96)))))))) (forall ((v_weq0_1 Int)) (let ((.cse115 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse101 (+ c_main_~list~5.offset 4))) (let ((.cse107 (select |c_#valid| c_main_~list~5.offset)) (.cse109 (select .cse115 .cse101)) (.cse116 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse106 (select |c_old(#valid)| 0))) (let ((.cse105 (not (= c_main_~list~5.base 0))) (.cse108 (not (= 0 c_main_~list~5.base))) (.cse111 (= 0 .cse106)) (.cse102 (not (= v_weq0_1 0))) (.cse103 (select .cse116 .cse101)) (.cse110 (= .cse107 .cse109)) (.cse104 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (or (and (not (= v_weq0_1 .cse101)) .cse102) (and (= .cse103 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse104 |c_#NULL.base|) .cse105 (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse104) (= .cse106 .cse107) .cse108 (= |c_#NULL.offset| .cse103) (= .cse109 v_weq0_1) .cse110 .cse111) (let ((.cse114 (select .cse116 v_weq0_1))) (let ((.cse112 (select |c_old(#valid)| .cse114)) (.cse113 (select .cse115 v_weq0_1))) (and (= .cse112 |c_#NULL.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse105 (= .cse106 .cse113) .cse108 (= .cse114 .cse112) (= .cse113 .cse107) (= .cse101 v_weq0_1) .cse111 (= .cse104 .cse114) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse103 0) .cse102 (= c_main_~list~5.offset .cse103) .cse110 (= .cse109 .cse104)))) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (forall ((v_weq0_1 Int)) (let ((.cse129 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse117 (+ c_main_~list~5.offset 4))) (let ((.cse123 (select |c_#valid| c_main_~list~5.offset)) (.cse125 (select .cse129 .cse117)) (.cse130 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse122 (select |c_old(#valid)| 0))) (let ((.cse121 (not (= c_main_~list~5.base 0))) (.cse124 (not (= 0 c_main_~list~5.base))) (.cse127 (= 0 .cse122)) (.cse118 (select .cse130 v_weq0_1)) (.cse119 (select .cse130 .cse117)) (.cse126 (= .cse123 .cse125)) (.cse120 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (or (and (not (= v_weq0_1 .cse117)) (not (= v_weq0_1 0))) (= .cse118 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1)) (and (= .cse119 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse120 |c_#NULL.base|) .cse121 (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse120) (= .cse122 .cse123) .cse124 (= |c_#NULL.offset| .cse119) (= .cse125 v_weq0_1) .cse126 .cse127) (let ((.cse128 (select .cse129 v_weq0_1))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse121 (= .cse122 .cse128) (= .cse118 |c_#NULL.offset|) .cse124 (= .cse128 .cse123) (= .cse117 v_weq0_1) .cse127 (= .cse120 .cse118) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse119 0) (= c_main_~list~5.offset .cse119) .cse126 (= .cse125 .cse120)))))))) (not (= |c_#valid| |c_#length|)) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse157 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse152 (+ c_main_~list~5.offset 4))) (let ((.cse155 (select .cse157 .cse152)) (.cse131 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse143 (select |c_old(#valid)| v_weq0_1)) (.cse160 (select |c_#valid| v_weq0_1)) (.cse161 (select |c_old(#valid)| 0)) (.cse159 (select |c_#valid| c_main_~list~5.offset)) (.cse158 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse156 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse132 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse133 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse134 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse132)) (.cse136 (= .cse158 .cse156)) (.cse146 (= .cse161 .cse159)) (.cse137 (not (= 0 c_main_~list~5.base))) (.cse147 (= .cse160 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse148 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse149 (= 0 .cse161)) (.cse150 (= 1 .cse160)) (.cse138 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse151 (= (select .cse156 .cse152) .cse143)) (.cse140 (select .cse158 .cse152)) (.cse139 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse141 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse145 (= .cse157 .cse131)) (.cse153 (= .cse159 .cse155)) (.cse154 (= (select |c_#length| v_weq0_1) 8))) (or (= (select .cse131 v_weq1_1) (select .cse132 v_weq1_1)) (let ((.cse142 (select .cse158 v_weq1_1)) (.cse135 (select .cse157 v_weq1_1)) (.cse144 (select .cse156 v_weq1_1))) (and .cse133 .cse134 (= |c_#NULL.offset| .cse135) .cse136 .cse137 .cse138 .cse139 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse140 0) (= .cse141 .cse142) (= .cse143 .cse144) .cse145 (= c_main_~list~5.offset .cse140) (= .cse142 |c_#NULL.offset|) .cse146 .cse147 .cse148 .cse149 .cse150 .cse151 (= .cse135 |c_main_#t~malloc0.offset|) (= .cse144 |c_#NULL.base|) (= .cse152 v_weq1_1) .cse153 .cse154 (= .cse155 .cse141))) (and .cse133 .cse134 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse141 |c_#NULL.offset|) .cse136 (= c_main_~list~5.offset 0) .cse146 .cse137 .cse147 .cse148 .cse149 .cse150 .cse138 .cse151 (= .cse140 c_main_~list~5.offset) (= |c_#NULL.base| .cse140) .cse139 (= v_weq1_1 .cse141) (= .cse143 |c_#NULL.base|) .cse145 (= .cse155 v_weq1_1) .cse153 .cse154)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse181 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse182 (+ c_main_~list~5.offset 4))) (let ((.cse185 (select .cse181 .cse182)) (.cse171 (select |c_old(#valid)| v_weq0_1)) (.cse187 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse190 (select |c_#valid| v_weq0_1)) (.cse191 (select |c_old(#valid)| 0)) (.cse188 (select |c_#valid| c_main_~list~5.offset)) (.cse186 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse189 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse172 (select .cse189 v_weq1_1)) (.cse162 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse163 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse174 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse164 (= .cse186 .cse189)) (.cse175 (= .cse191 .cse188)) (.cse165 (not (= 0 c_main_~list~5.base))) (.cse176 (= .cse190 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse177 (= .cse187 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse178 (= 0 .cse191)) (.cse179 (= 1 .cse190)) (.cse166 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse180 (= (select .cse189 .cse182) .cse171)) (.cse168 (select .cse186 .cse182)) (.cse167 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse169 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse173 (= .cse181 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse183 (= .cse188 .cse185)) (.cse184 (= (select |c_#length| v_weq0_1) 8))) (or (let ((.cse170 (select .cse186 v_weq1_1))) (and .cse162 .cse163 .cse164 .cse165 .cse166 .cse167 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse168 0) (= .cse169 .cse170) (= .cse171 .cse172) .cse173 (= c_main_~list~5.offset .cse168) (= .cse170 |c_#NULL.offset|) .cse174 .cse175 .cse176 .cse177 .cse178 .cse179 .cse180 (= |c_main_#t~malloc0.offset| (select .cse181 v_weq1_1)) (= .cse172 |c_#NULL.base|) (= .cse182 v_weq1_1) .cse183 .cse184 (= .cse185 .cse169))) (= (select .cse187 v_weq1_1) .cse172) (and .cse162 .cse163 .cse174 (= .cse169 |c_#NULL.offset|) .cse164 (= c_main_~list~5.offset 0) .cse175 .cse165 .cse176 .cse177 .cse178 .cse179 .cse166 .cse180 (= .cse168 c_main_~list~5.offset) (= |c_#NULL.base| .cse168) .cse167 (= v_weq1_1 .cse169) (= .cse171 |c_#NULL.base|) .cse173 (= .cse185 v_weq1_1) .cse183 .cse184)))))) (forall ((v_weq0_1 Int)) (or (= (select |c_old(#valid)| v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (let ((.cse197 (+ c_main_~list~5.offset 4))) (let ((.cse193 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse192 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse197)) (.cse195 (select |c_#valid| c_main_~list~5.offset)) (.cse196 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse197)) (.cse194 (select |c_old(#valid)| 0))) (and (= .cse192 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse193 |c_#NULL.base|) (not (= c_main_~list~5.base 0)) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse193) (= .cse194 .cse195) (not (= 0 c_main_~list~5.base)) (= |c_#NULL.offset| .cse192) (= .cse196 v_weq0_1) (= .cse195 .cse196) (= 0 .cse194)))) (not (= v_weq0_1 0)))) (not (= |c_#length| |c_old(#valid)|)) (forall ((v_weq0_1 Int)) (let ((.cse207 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse198 (select .cse207 v_weq0_1))) (or (not (= v_weq0_1 0)) (= .cse198 (select |c_old(#valid)| v_weq0_1)) (let ((.cse202 (+ c_main_~list~5.offset 4)) (.cse206 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse200 (select .cse206 v_weq0_1)) (.cse199 (select |c_old(#valid)| 0)) (.cse204 (select .cse207 .cse202)) (.cse201 (select |c_#valid| c_main_~list~5.offset)) (.cse205 (select .cse206 .cse202)) (.cse203 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse199 .cse200) (= .cse198 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse200 .cse201) (= .cse202 v_weq0_1) (= 0 .cse199) (= .cse203 .cse198) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse204 0) (= c_main_~list~5.offset .cse204) (= .cse201 .cse205) (= .cse205 .cse203)))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse239 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse238 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse232 (+ c_main_~list~5.offset 4))) (let ((.cse236 (select .cse238 .cse232)) (.cse237 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse223 (select .cse239 .cse232)) (.cse241 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse244 (select |c_#valid| v_weq0_1)) (.cse245 (select |c_old(#valid)| 0)) (.cse243 (select |c_#valid| c_main_~list~5.offset)) (.cse240 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse242 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse208 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse209 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse242)) (.cse211 (= .cse239 .cse240)) (.cse226 (= c_main_~list~5.offset 0)) (.cse227 (= .cse245 .cse243)) (.cse213 (not (= 0 c_main_~list~5.base))) (.cse228 (= .cse244 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse229 (= .cse241 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse230 (= 0 .cse245)) (.cse231 (= 1 .cse244)) (.cse214 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse224 (select .cse240 .cse232)) (.cse215 (= .cse223 c_main_~list~5.offset)) (.cse216 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse217 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse219 (select |c_old(#valid)| v_weq0_1)) (.cse221 (= .cse238 .cse237)) (.cse234 (= .cse243 .cse236)) (.cse235 (= (select |c_#length| v_weq0_1) 8)) (.cse233 (not (= v_weq1_1 0)))) (or (let ((.cse220 (select .cse240 v_weq1_1)) (.cse218 (select .cse239 v_weq1_1))) (let ((.cse212 (select |c_old(#valid)| .cse218)) (.cse225 (select |c_old(#valid)| .cse220)) (.cse210 (select .cse238 v_weq1_1)) (.cse222 (select .cse237 .cse232))) (and .cse208 .cse209 (= |c_#NULL.offset| .cse210) .cse211 (= |c_#NULL.base| .cse212) .cse213 .cse214 .cse215 .cse216 (= .cse217 .cse218) (= .cse219 .cse220) .cse221 (= .cse218 |c_#NULL.offset|) (= .cse222 |c_#NULL.base|) (= .cse212 .cse223) (= .cse224 .cse225) .cse226 .cse227 (= .cse225 .cse219) .cse228 .cse229 .cse230 .cse231 (= .cse210 |c_main_#t~malloc0.offset|) (= .cse232 v_weq1_1) .cse233 .cse234 (= .cse220 .cse222) .cse235 (= .cse236 .cse217)))) (not (= v_weq0_1 c_main_~list~5.base)) (and .cse208 .cse209 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse217 |c_#NULL.offset|) .cse211 .cse226 .cse227 .cse213 .cse228 .cse229 .cse230 .cse231 .cse214 (= .cse224 .cse219) .cse215 (= |c_#NULL.base| .cse223) .cse216 (= v_weq1_1 .cse217) (= .cse219 |c_#NULL.base|) .cse221 (= .cse236 v_weq1_1) .cse234 .cse235) (= (select .cse241 v_weq1_1) (select .cse242 v_weq1_1)) (and (not (= v_weq1_1 .cse232)) .cse233)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse265 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse266 (+ c_main_~list~5.offset 4))) (let ((.cse269 (select .cse265 .cse266)) (.cse255 (select |c_old(#valid)| v_weq0_1)) (.cse274 (select |c_#valid| v_weq0_1)) (.cse275 (select |c_old(#valid)| 0)) (.cse272 (select |c_#valid| c_main_~list~5.offset)) (.cse270 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse271 (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (.cse273 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse256 (select .cse273 v_weq1_1)) (.cse246 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse247 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse271)) (.cse258 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse248 (= .cse270 .cse273)) (.cse259 (= .cse275 .cse272)) (.cse249 (not (= 0 c_main_~list~5.base))) (.cse260 (= .cse274 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse261 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse262 (= 0 .cse275)) (.cse263 (= 1 .cse274)) (.cse250 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse264 (= (select .cse273 .cse266) .cse255)) (.cse252 (select .cse270 .cse266)) (.cse251 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse253 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse257 (= .cse265 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse267 (= .cse272 .cse269)) (.cse268 (= (select |c_#length| v_weq0_1) 8))) (or (let ((.cse254 (select .cse270 v_weq1_1))) (and .cse246 .cse247 .cse248 .cse249 .cse250 .cse251 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse252 0) (= .cse253 .cse254) (= .cse255 .cse256) .cse257 (= c_main_~list~5.offset .cse252) (= .cse254 |c_#NULL.offset|) .cse258 .cse259 .cse260 .cse261 .cse262 .cse263 .cse264 (= |c_main_#t~malloc0.offset| (select .cse265 v_weq1_1)) (= .cse256 |c_#NULL.base|) (= .cse266 v_weq1_1) .cse267 .cse268 (= .cse269 .cse253))) (= .cse256 (select .cse271 v_weq1_1)) (not (= v_weq0_1 c_main_~list~5.base)) (and .cse246 .cse247 .cse258 (= .cse253 |c_#NULL.offset|) .cse248 (= c_main_~list~5.offset 0) .cse259 .cse249 .cse260 .cse261 .cse262 .cse263 .cse250 .cse264 (= .cse252 c_main_~list~5.offset) (= |c_#NULL.base| .cse252) .cse251 (= v_weq1_1 .cse253) (= .cse255 |c_#NULL.base|) .cse257 (= .cse269 v_weq1_1) .cse267 .cse268) (and (not (= v_weq1_1 .cse266)) (not (= v_weq1_1 0)))))))) (forall ((v_weq0_1 Int)) (let ((.cse285 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse276 (select .cse285 v_weq0_1))) (or (= .cse276 (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse280 (+ c_main_~list~5.offset 4)) (.cse284 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse278 (select .cse284 v_weq0_1)) (.cse277 (select |c_old(#valid)| 0)) (.cse282 (select .cse285 .cse280)) (.cse279 (select |c_#valid| c_main_~list~5.offset)) (.cse283 (select .cse284 .cse280)) (.cse281 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse277 .cse278) (= .cse276 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse278 .cse279) (= .cse280 v_weq0_1) (= 0 .cse277) (= .cse281 .cse276) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse282 0) (= c_main_~list~5.offset .cse282) (= .cse279 .cse283) (= .cse283 .cse281)))))))) (forall ((v_weq0_1 Int)) (let ((.cse299 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse297 (+ c_main_~list~5.offset 4))) (let ((.cse290 (select |c_#valid| c_main_~list~5.offset)) (.cse292 (select .cse299 .cse297)) (.cse298 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse289 (select |c_old(#valid)| 0))) (let ((.cse288 (not (= c_main_~list~5.base 0))) (.cse291 (not (= 0 c_main_~list~5.base))) (.cse295 (select .cse299 v_weq0_1)) (.cse294 (= 0 .cse289)) (.cse286 (select .cse298 .cse297)) (.cse293 (= .cse290 .cse292)) (.cse287 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (or (and (= .cse286 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse287 |c_#NULL.base|) .cse288 (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse287) (= .cse289 .cse290) .cse291 (= |c_#NULL.offset| .cse286) (= .cse292 v_weq0_1) .cse293 .cse294) (= .cse295 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1)) (let ((.cse296 (select .cse298 v_weq0_1))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse288 (= .cse289 .cse295) (= .cse296 |c_#NULL.offset|) .cse291 (= .cse295 .cse290) (= .cse297 v_weq0_1) .cse294 (= .cse287 .cse296) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse286 0) (= c_main_~list~5.offset .cse286) .cse293 (= .cse292 .cse287)))))))) (= .cse300 .cse301) (= |c_#NULL.offset| .cse16) (= 0 .cse300) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 (+ c_main_~list~5.offset 4))) (not (= v_weq0_1 0))))) (= .cse302 |c_#NULL.base|) (forall ((v_weq0_1 Int)) (let ((.cse316 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse304 (+ c_main_~list~5.offset 4))) (let ((.cse309 (select |c_#valid| c_main_~list~5.offset)) (.cse311 (select .cse316 .cse304)) (.cse315 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse308 (select |c_old(#valid)| 0))) (let ((.cse307 (not (= c_main_~list~5.base 0))) (.cse310 (not (= 0 c_main_~list~5.base))) (.cse303 (select .cse316 v_weq0_1)) (.cse313 (= 0 .cse308)) (.cse305 (select .cse315 .cse304)) (.cse312 (= .cse309 .cse311)) (.cse306 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (or (= .cse303 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 .cse304)) (not (= v_weq0_1 0))) (and (= .cse305 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse306 |c_#NULL.base|) .cse307 (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse306) (= .cse308 .cse309) .cse310 (= |c_#NULL.offset| .cse305) (= .cse311 v_weq0_1) .cse312 .cse313) (let ((.cse314 (select .cse315 v_weq0_1))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse307 (= .cse308 .cse303) (= .cse314 |c_#NULL.offset|) .cse310 (= .cse303 .cse309) (= .cse304 v_weq0_1) .cse313 (= .cse306 .cse314) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse305 0) (= c_main_~list~5.offset .cse305) .cse312 (= .cse311 .cse306)))))))) (forall ((v_weq0_1 Int)) (or (let ((.cse322 (+ c_main_~list~5.offset 4))) (let ((.cse318 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse317 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse322)) (.cse320 (select |c_#valid| c_main_~list~5.offset)) (.cse321 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse322)) (.cse319 (select |c_old(#valid)| 0))) (and (= .cse317 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse318 |c_#NULL.base|) (not (= c_main_~list~5.base 0)) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse318) (= .cse319 .cse320) (not (= 0 c_main_~list~5.base)) (= |c_#NULL.offset| .cse317) (= .cse321 v_weq0_1) (= .cse320 .cse321) (= 0 .cse319)))) (= (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))) (= .cse301 .cse323) (= .cse323 .cse302) (= 1 (select |c_#valid| |c_main_#t~malloc0.base|)) (not (= |c_#valid| |c_old(#valid)|))))) is different from false [2018-01-21 10:54:00,693 WARN L1007 $PredicateComparison]: unable to prove that (let ((.cse349 (+ c_main_~list~5.offset 4))) (let ((.cse86 (select |c_old(#valid)| 0)) (.cse66 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse349)) (.cse183 (select |c_#valid| c_main_~list~5.offset)) (.cse342 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse349)) (.cse132 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (forall ((v_weq0_1 Int)) (let ((.cse15 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse14 (+ c_main_~list~5.offset 4))) (let ((.cse5 (select |c_#valid| c_main_~list~5.offset)) (.cse10 (select .cse15 .cse14)) (.cse16 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse2 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse4 (select |c_old(#valid)| 0))) (let ((.cse0 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse1 (= 0 |c_main_#t~mem10.base|)) (.cse3 (not (= c_main_~list~5.base 0))) (.cse6 (not (= 0 c_main_~list~5.base))) (.cse8 (= |c_main_#t~mem10.base| .cse4)) (.cse9 (= |c_main_#t~mem10.offset| .cse2)) (.cse7 (select .cse16 .cse14)) (.cse11 (= .cse5 .cse10)) (.cse13 (select .cse16 v_weq0_1))) (or (and .cse0 .cse1 (= .cse2 |c_#NULL.offset|) .cse3 (= c_main_~list~5.offset 0) (= .cse4 .cse5) .cse6 (= .cse7 c_main_~list~5.offset) .cse8 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse7) .cse9 (= .cse10 v_weq0_1) .cse11) (let ((.cse12 (select .cse15 v_weq0_1))) (and (= .cse10 |c_main_#t~mem10.offset|) .cse0 .cse1 .cse3 (= .cse4 .cse12) (= .cse13 |c_#NULL.offset|) .cse6 (= .cse12 .cse5) (= .cse14 v_weq0_1) .cse8 (= .cse2 .cse13) .cse9 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse7 0) (= c_main_~list~5.offset .cse7) .cse11)) (= .cse13 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (or (not (= v_weq0_1 c_main_~list~5.base)) (and (not (= v_weq1_1 (+ c_main_~list~5.offset 4))) (not (= v_weq1_1 0))) (= (select (select |c_#memory_$Pointer$.base| v_weq0_1) v_weq1_1) (select (select |c_#memory_$Pointer$.offset| v_weq0_1) v_weq1_1)))) (not (= 0 c_main_~list~5.base)) (forall ((v_weq0_1 Int)) (let ((.cse33 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse18 (+ c_main_~list~5.offset 4))) (let ((.cse26 (select |c_#valid| c_main_~list~5.offset)) (.cse31 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse23 (select |c_old(#valid)| 0)) (.cse32 (select .cse33 .cse18))) (let ((.cse17 (select .cse33 v_weq0_1)) (.cse19 (= .cse32 |c_main_#t~mem10.offset|)) (.cse20 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse21 (= 0 |c_main_#t~mem10.base|)) (.cse22 (not (= c_main_~list~5.base 0))) (.cse28 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse25 (not (= 0 c_main_~list~5.base))) (.cse27 (= |c_main_#t~mem10.base| .cse23)) (.cse29 (select .cse31 .cse18)) (.cse30 (= .cse26 .cse32))) (or (= .cse17 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 .cse18)) (not (= v_weq0_1 0))) (let ((.cse24 (select .cse31 v_weq0_1))) (and .cse19 .cse20 .cse21 .cse22 (= .cse23 .cse17) (= .cse24 |c_#NULL.offset|) .cse25 (= .cse17 .cse26) (= .cse18 v_weq0_1) .cse27 (= .cse28 .cse24) (= |c_main_#t~mem10.offset| .cse28) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse29 0) (= c_main_~list~5.offset .cse29) .cse30)) (and .cse19 .cse20 .cse21 (= .cse28 |c_#NULL.offset|) .cse22 (= v_weq0_1 .cse28) (= c_main_~list~5.offset 0) (= .cse23 .cse26) .cse25 (= .cse29 c_main_~list~5.offset) .cse27 (= |c_#NULL.base| .cse29) (= |c_main_#t~mem10.offset| v_weq0_1) .cse30)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse56 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse57 (+ c_main_~list~5.offset 4))) (let ((.cse36 (select .cse56 .cse57)) (.cse46 (select |c_old(#valid)| v_weq0_1)) (.cse61 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse64 (select |c_#valid| v_weq0_1)) (.cse62 (select |c_#valid| c_main_~list~5.offset)) (.cse44 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse65 (select |c_old(#valid)| 0)) (.cse60 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse63 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse47 (select .cse63 v_weq1_1)) (.cse34 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse35 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse37 (= .cse60 .cse63)) (.cse38 (not (= 0 c_main_~list~5.base))) (.cse39 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse40 (= |c_main_#t~mem10.base| .cse65)) (.cse43 (select .cse60 .cse57)) (.cse41 (= |c_main_#t~mem10.offset| .cse44)) (.cse42 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse48 (= .cse56 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse49 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse50 (= 0 |c_main_#t~mem10.base|)) (.cse51 (= .cse65 .cse62)) (.cse52 (= .cse64 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse53 (= .cse61 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse54 (= 1 .cse64)) (.cse55 (= (select .cse63 .cse57) .cse46)) (.cse58 (= .cse62 .cse36)) (.cse59 (= (select |c_#length| v_weq0_1) 8))) (or (let ((.cse45 (select .cse60 v_weq1_1))) (and .cse34 .cse35 (= .cse36 |c_main_#t~mem10.offset|) .cse37 .cse38 .cse39 .cse40 .cse41 .cse42 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse43 0) (= .cse44 .cse45) (= .cse46 .cse47) .cse48 (= c_main_~list~5.offset .cse43) (= .cse45 |c_#NULL.offset|) .cse49 .cse50 .cse51 .cse52 .cse53 .cse54 .cse55 (= |c_main_#t~malloc0.offset| (select .cse56 v_weq1_1)) (= .cse47 |c_#NULL.base|) (= .cse57 v_weq1_1) .cse58 .cse59)) (= (select .cse61 v_weq1_1) .cse47) (and .cse34 .cse35 .cse37 .cse38 .cse39 (= .cse43 c_main_~list~5.offset) .cse40 (= |c_#NULL.base| .cse43) .cse41 .cse42 (= .cse46 |c_#NULL.base|) .cse48 .cse49 .cse50 (= .cse44 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse51 .cse52 .cse53 .cse54 .cse55 (= .cse36 v_weq1_1) .cse58 .cse59)))))) (= .cse66 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (forall ((v_weq0_1 Int)) (let ((.cse83 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse77 (+ c_main_~list~5.offset 4))) (let ((.cse76 (select |c_#valid| c_main_~list~5.offset)) (.cse84 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse72 (select |c_old(#valid)| 0)) (.cse85 (select .cse83 .cse77))) (let ((.cse81 (not (= v_weq0_1 0))) (.cse68 (= .cse85 |c_main_#t~mem10.offset|)) (.cse69 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse70 (= 0 |c_main_#t~mem10.base|)) (.cse71 (not (= c_main_~list~5.base 0))) (.cse79 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse74 (not (= 0 c_main_~list~5.base))) (.cse78 (= |c_main_#t~mem10.base| .cse72)) (.cse80 (select .cse84 .cse77)) (.cse82 (= .cse76 .cse85))) (or (let ((.cse75 (select .cse84 v_weq0_1))) (let ((.cse67 (select |c_old(#valid)| .cse75)) (.cse73 (select .cse83 v_weq0_1))) (and (= .cse67 |c_#NULL.offset|) .cse68 .cse69 .cse70 .cse71 (= .cse72 .cse73) .cse74 (= .cse75 .cse67) (= .cse73 .cse76) (= .cse77 v_weq0_1) .cse78 (= .cse79 .cse75) (= |c_main_#t~mem10.offset| .cse79) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse80 0) .cse81 (= c_main_~list~5.offset .cse80) .cse82))) (and (not (= v_weq0_1 .cse77)) .cse81) (and .cse68 .cse69 .cse70 (= .cse79 |c_#NULL.offset|) .cse71 (= v_weq0_1 .cse79) (= c_main_~list~5.offset 0) (= .cse72 .cse76) .cse74 (= .cse80 c_main_~list~5.offset) .cse78 (= |c_#NULL.base| .cse80) (= |c_main_#t~mem10.offset| v_weq0_1) .cse82) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (= |c_main_#t~mem10.base| .cse86) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse92 (+ c_main_~list~5.offset 4))) (let ((.cse88 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse89 (select |c_old(#valid)| 0)) (.cse91 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse92)) (.cse90 (select |c_#valid| c_main_~list~5.offset)) (.cse87 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse92))) (and (= .cse87 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse88 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse88) (= c_main_~list~5.offset 0) (= .cse89 .cse90) (not (= 0 c_main_~list~5.base)) (= .cse91 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse89) (= |c_#NULL.base| .cse91) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse90 .cse87)))))) (not (= |c_#valid| |c_#length|)) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse98 (+ c_main_~list~5.offset 4))) (let ((.cse94 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse95 (select |c_old(#valid)| 0)) (.cse97 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse98)) (.cse96 (select |c_#valid| c_main_~list~5.offset)) (.cse93 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse98))) (and (= .cse93 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse94 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse94) (= c_main_~list~5.offset 0) (= .cse95 .cse96) (not (= 0 c_main_~list~5.base)) (= .cse97 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse95) (= |c_#NULL.base| .cse97) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse96 .cse93)))))) (forall ((v_weq0_1 Int)) (or (= (select |c_old(#valid)| v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse104 (+ c_main_~list~5.offset 4))) (let ((.cse100 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse101 (select |c_old(#valid)| 0)) (.cse103 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse104)) (.cse102 (select |c_#valid| c_main_~list~5.offset)) (.cse99 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse104))) (and (= .cse99 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse100 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse100) (= c_main_~list~5.offset 0) (= .cse101 .cse102) (not (= 0 c_main_~list~5.base)) (= .cse103 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse101) (= |c_#NULL.base| .cse103) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse102 .cse99)))))) (not (= |c_#length| |c_old(#valid)|)) (= |c_main_#t~mem10.offset| |c_#NULL.base|) (forall ((v_weq0_1 Int)) (let ((.cse113 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse105 (select .cse113 v_weq0_1))) (or (= .cse105 (select |c_#valid| v_weq0_1)) (let ((.cse110 (+ c_main_~list~5.offset 4)) (.cse114 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse107 (select |c_old(#valid)| 0)) (.cse108 (select .cse114 v_weq0_1)) (.cse111 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse112 (select .cse114 .cse110)) (.cse109 (select |c_#valid| c_main_~list~5.offset)) (.cse106 (select .cse113 .cse110))) (and (= .cse106 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (not (= c_main_~list~5.base 0)) (= .cse107 .cse105) (= .cse108 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse105 .cse109) (= .cse110 v_weq0_1) (= |c_main_#t~mem10.base| .cse107) (= .cse111 .cse108) (= |c_main_#t~mem10.offset| .cse111) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse112 0) (= c_main_~list~5.offset .cse112) (= .cse109 .cse106)))) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int)) (let ((.cse130 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse127 (+ c_main_~list~5.offset 4))) (let ((.cse120 (select |c_#valid| c_main_~list~5.offset)) (.cse125 (select .cse130 .cse127)) (.cse117 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse131 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse119 (select |c_old(#valid)| 0))) (let ((.cse115 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse116 (= 0 |c_main_#t~mem10.base|)) (.cse118 (not (= c_main_~list~5.base 0))) (.cse121 (not (= 0 c_main_~list~5.base))) (.cse123 (= |c_main_#t~mem10.base| .cse119)) (.cse128 (select .cse131 v_weq0_1)) (.cse124 (= |c_main_#t~mem10.offset| .cse117)) (.cse122 (select .cse131 .cse127)) (.cse126 (= .cse120 .cse125))) (or (and .cse115 .cse116 (= .cse117 |c_#NULL.offset|) .cse118 (= c_main_~list~5.offset 0) (= .cse119 .cse120) .cse121 (= .cse122 c_main_~list~5.offset) .cse123 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse122) .cse124 (= .cse125 v_weq0_1) .cse126) (and (not (= v_weq0_1 .cse127)) (not (= v_weq0_1 0))) (= .cse128 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1)) (let ((.cse129 (select .cse130 v_weq0_1))) (and (= .cse125 |c_main_#t~mem10.offset|) .cse115 .cse116 .cse118 (= .cse119 .cse129) (= .cse128 |c_#NULL.offset|) .cse121 (= .cse129 .cse120) (= .cse127 v_weq0_1) .cse123 (= .cse117 .cse128) .cse124 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse122 0) (= c_main_~list~5.offset .cse122) .cse126))))))) (= 0 |c_main_#t~mem10.base|) (= .cse132 |c_main_#t~mem10.offset|) (forall ((v_weq0_1 Int)) (let ((.cse134 (select |c_#valid| v_weq0_1)) (.cse133 (select |c_old(#valid)| v_weq0_1))) (or (= .cse133 .cse134) (let ((.cse141 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse136 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse143 (+ c_main_~list~5.offset 4))) (let ((.cse138 (select .cse136 .cse143)) (.cse140 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse139 (select |c_old(#valid)| 0)) (.cse137 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse142 (select |c_#valid| c_main_~list~5.offset)) (.cse135 (select .cse141 .cse143))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse135 |c_main_#t~mem10.offset|) (not (= c_main_~list~5.base 0)) (= .cse136 .cse137) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= .cse138 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse139) (= |c_#NULL.base| .cse138) (= |c_main_#t~mem10.offset| .cse140) (= v_weq0_1 |c_main_#t~malloc0.base|) (= .cse133 |c_#NULL.base|) (= .cse141 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse140 |c_#NULL.offset|) (= c_main_~list~5.offset 0) (= .cse139 .cse142) (= .cse134 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 1 .cse134) (= (select .cse137 .cse143) .cse133) (= .cse142 .cse135) (= (select |c_#length| v_weq0_1) 8))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse175 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse172 (+ c_main_~list~5.offset 4))) (let ((.cse163 (select .cse175 .cse172)) (.cse178 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse181 (select |c_#valid| v_weq0_1)) (.cse180 (select |c_#valid| c_main_~list~5.offset)) (.cse174 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse157 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse182 (select |c_old(#valid)| 0)) (.cse177 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse176 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse179 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse144 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse145 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse179)) (.cse146 (not (= c_main_~list~5.base 0))) (.cse147 (= .cse177 .cse176)) (.cse148 (not (= 0 c_main_~list~5.base))) (.cse149 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse151 (= |c_main_#t~mem10.base| .cse182)) (.cse152 (= |c_main_#t~mem10.offset| .cse157)) (.cse153 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse155 (= .cse175 .cse174)) (.cse150 (select .cse177 .cse172)) (.cse156 (= 0 |c_main_#t~mem10.base|)) (.cse162 (select .cse176 .cse172)) (.cse158 (= .cse182 .cse180)) (.cse154 (select |c_old(#valid)| v_weq0_1)) (.cse159 (= .cse181 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse160 (= .cse178 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse161 (= 1 .cse181)) (.cse164 (= .cse180 .cse163)) (.cse165 (= (select |c_#length| v_weq0_1) 8)) (.cse173 (not (= v_weq1_1 0)))) (or (and .cse144 .cse145 .cse146 .cse147 .cse148 .cse149 (= .cse150 c_main_~list~5.offset) .cse151 (= |c_#NULL.base| .cse150) .cse152 .cse153 (= .cse154 |c_#NULL.base|) .cse155 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse156 (= .cse157 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse158 .cse159 .cse160 .cse161 (= .cse162 .cse154) (= .cse163 v_weq1_1) .cse164 .cse165) (not (= v_weq0_1 c_main_~list~5.base)) (let ((.cse168 (select .cse177 v_weq1_1)) (.cse169 (select .cse176 v_weq1_1))) (let ((.cse171 (select |c_old(#valid)| .cse169)) (.cse167 (select |c_old(#valid)| .cse168)) (.cse166 (select .cse175 v_weq1_1)) (.cse170 (select .cse174 .cse172))) (and .cse144 .cse145 (= .cse163 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse166) .cse146 .cse147 (= |c_#NULL.base| .cse167) .cse148 .cse149 .cse151 .cse152 .cse153 (= .cse150 0) (= .cse157 .cse168) (= .cse154 .cse169) .cse155 (= c_main_~list~5.offset .cse150) (= .cse168 |c_#NULL.offset|) (= .cse170 |c_#NULL.base|) .cse156 (= .cse162 .cse171) .cse158 (= .cse171 .cse154) .cse159 (= .cse167 c_main_~list~5.offset) .cse160 .cse161 (= .cse166 |c_main_#t~malloc0.offset|) (= .cse172 v_weq1_1) .cse173 .cse164 (= .cse169 .cse170) .cse165))) (= (select .cse178 v_weq1_1) (select .cse179 v_weq1_1)) (and (not (= v_weq1_1 .cse172)) .cse173)))))) (= .cse86 .cse183) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse212 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse208 (+ c_main_~list~5.offset 4))) (let ((.cse188 (select .cse212 .cse208)) (.cse199 (select |c_old(#valid)| v_weq0_1)) (.cse215 (select |c_#valid| v_weq0_1)) (.cse214 (select |c_#valid| c_main_~list~5.offset)) (.cse184 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse197 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse216 (select |c_old(#valid)| 0)) (.cse213 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse211 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse185 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse186 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse187 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse185)) (.cse190 (= .cse213 .cse211)) (.cse191 (not (= 0 c_main_~list~5.base))) (.cse192 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse193 (= |c_main_#t~mem10.base| .cse216)) (.cse196 (select .cse213 .cse208)) (.cse194 (= |c_main_#t~mem10.offset| .cse197)) (.cse195 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse201 (= .cse212 .cse184)) (.cse202 (= 0 |c_main_#t~mem10.base|)) (.cse203 (= .cse216 .cse214)) (.cse204 (= .cse215 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse205 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse206 (= 1 .cse215)) (.cse207 (= (select .cse211 .cse208) .cse199)) (.cse209 (= .cse214 .cse188)) (.cse210 (= (select |c_#length| v_weq0_1) 8))) (or (= (select .cse184 v_weq1_1) (select .cse185 v_weq1_1)) (let ((.cse198 (select .cse213 v_weq1_1)) (.cse189 (select .cse212 v_weq1_1)) (.cse200 (select .cse211 v_weq1_1))) (and .cse186 .cse187 (= .cse188 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse189) .cse190 .cse191 .cse192 .cse193 .cse194 .cse195 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse196 0) (= .cse197 .cse198) (= .cse199 .cse200) .cse201 (= c_main_~list~5.offset .cse196) (= .cse198 |c_#NULL.offset|) .cse202 .cse203 .cse204 .cse205 .cse206 .cse207 (= .cse189 |c_main_#t~malloc0.offset|) (= .cse200 |c_#NULL.base|) (= .cse208 v_weq1_1) .cse209 .cse210)) (and .cse186 .cse187 .cse190 .cse191 .cse192 (= .cse196 c_main_~list~5.offset) .cse193 (= |c_#NULL.base| .cse196) .cse194 .cse195 (= .cse199 |c_#NULL.base|) .cse201 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse202 (= .cse197 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse203 .cse204 .cse205 .cse206 .cse207 (= .cse188 v_weq1_1) .cse209 .cse210)))))) (forall ((v_weq0_1 Int)) (let ((.cse233 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse231 (+ c_main_~list~5.offset 4))) (let ((.cse222 (select |c_#valid| c_main_~list~5.offset)) (.cse227 (select .cse233 .cse231)) (.cse232 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse219 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse221 (select |c_old(#valid)| 0))) (let ((.cse217 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse218 (= 0 |c_main_#t~mem10.base|)) (.cse220 (not (= c_main_~list~5.base 0))) (.cse223 (not (= 0 c_main_~list~5.base))) (.cse225 (= |c_main_#t~mem10.base| .cse221)) (.cse226 (= |c_main_#t~mem10.offset| .cse219)) (.cse224 (select .cse232 .cse231)) (.cse228 (= .cse222 .cse227)) (.cse229 (select .cse233 v_weq0_1))) (or (and .cse217 .cse218 (= .cse219 |c_#NULL.offset|) .cse220 (= c_main_~list~5.offset 0) (= .cse221 .cse222) .cse223 (= .cse224 c_main_~list~5.offset) .cse225 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse224) .cse226 (= .cse227 v_weq0_1) .cse228) (let ((.cse230 (select .cse232 v_weq0_1))) (and (= .cse227 |c_main_#t~mem10.offset|) .cse217 .cse218 .cse220 (= .cse221 .cse229) (= .cse230 |c_#NULL.offset|) .cse223 (= .cse229 .cse222) (= .cse231 v_weq0_1) .cse225 (= .cse219 .cse230) .cse226 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse224 0) (= c_main_~list~5.offset .cse224) .cse228)) (= .cse229 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1))))))) (= |c_#NULL.offset| .cse66) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse263 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse256 (+ c_main_~list~5.offset 4))) (let ((.cse253 (select .cse263 .cse256)) (.cse244 (select |c_old(#valid)| v_weq0_1)) (.cse257 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse266 (select |c_#valid| v_weq0_1)) (.cse265 (select |c_#valid| c_main_~list~5.offset)) (.cse258 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse247 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse267 (select |c_old(#valid)| 0)) (.cse264 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse262 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse234 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse235 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse236 (not (= c_main_~list~5.base 0))) (.cse237 (= .cse264 .cse262)) (.cse238 (not (= 0 c_main_~list~5.base))) (.cse239 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse241 (= |c_main_#t~mem10.base| .cse267)) (.cse242 (= |c_main_#t~mem10.offset| .cse247)) (.cse243 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse245 (= .cse263 .cse258)) (.cse240 (select .cse264 .cse256)) (.cse246 (= 0 |c_main_#t~mem10.base|)) (.cse248 (= .cse267 .cse265)) (.cse249 (= .cse266 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse250 (= .cse257 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse251 (= 1 .cse266)) (.cse252 (= (select .cse262 .cse256) .cse244)) (.cse254 (= .cse265 .cse253)) (.cse255 (= (select |c_#length| v_weq0_1) 8))) (or (and .cse234 .cse235 .cse236 .cse237 .cse238 .cse239 (= .cse240 c_main_~list~5.offset) .cse241 (= |c_#NULL.base| .cse240) .cse242 .cse243 (= .cse244 |c_#NULL.base|) .cse245 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse246 (= .cse247 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse248 .cse249 .cse250 .cse251 .cse252 (= .cse253 v_weq1_1) .cse254 .cse255) (not (= v_weq0_1 c_main_~list~5.base)) (and (not (= v_weq1_1 .cse256)) (not (= v_weq1_1 0))) (= (select .cse257 v_weq1_1) (select .cse258 v_weq1_1)) (let ((.cse260 (select .cse264 v_weq1_1)) (.cse259 (select .cse263 v_weq1_1)) (.cse261 (select .cse262 v_weq1_1))) (and .cse234 .cse235 (= .cse253 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse259) .cse236 .cse237 .cse238 .cse239 .cse241 .cse242 .cse243 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse240 0) (= .cse247 .cse260) (= .cse244 .cse261) .cse245 (= c_main_~list~5.offset .cse240) (= .cse260 |c_#NULL.offset|) .cse246 .cse248 .cse249 .cse250 .cse251 .cse252 (= .cse259 |c_main_#t~malloc0.offset|) (= .cse261 |c_#NULL.base|) (= .cse256 v_weq1_1) .cse254 .cse255))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 (+ c_main_~list~5.offset 4))) (not (= v_weq0_1 0))))) (forall ((v_weq0_1 Int)) (let ((.cse277 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse271 (select .cse277 v_weq0_1))) (or (let ((.cse273 (+ c_main_~list~5.offset 4)) (.cse276 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse270 (select .cse276 v_weq0_1)) (.cse269 (select |c_old(#valid)| 0)) (.cse274 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse275 (select .cse277 .cse273)) (.cse272 (select |c_#valid| c_main_~list~5.offset)) (.cse268 (select .cse276 .cse273))) (and (= .cse268 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (not (= c_main_~list~5.base 0)) (= .cse269 .cse270) (= .cse271 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse270 .cse272) (= .cse273 v_weq0_1) (= |c_main_#t~mem10.base| .cse269) (= .cse274 .cse271) (= |c_main_#t~mem10.offset| .cse274) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse275 0) (= c_main_~list~5.offset .cse275) (= .cse272 .cse268)))) (not (= v_weq0_1 0)) (= .cse271 (select |c_old(#valid)| v_weq0_1)))))) (forall ((v_weq0_1 Int)) (let ((.cse286 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse278 (select .cse286 v_weq0_1))) (or (= .cse278 (select |c_old(#valid)| v_weq0_1)) (let ((.cse283 (+ c_main_~list~5.offset 4)) (.cse287 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse280 (select |c_old(#valid)| 0)) (.cse281 (select .cse287 v_weq0_1)) (.cse284 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse285 (select .cse287 .cse283)) (.cse282 (select |c_#valid| c_main_~list~5.offset)) (.cse279 (select .cse286 .cse283))) (and (= .cse279 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (not (= c_main_~list~5.base 0)) (= .cse280 .cse278) (= .cse281 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse278 .cse282) (= .cse283 v_weq0_1) (= |c_main_#t~mem10.base| .cse280) (= .cse284 .cse281) (= |c_main_#t~mem10.offset| .cse284) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse285 0) (= c_main_~list~5.offset .cse285) (= .cse282 .cse279)))) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse310 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse311 (+ c_main_~list~5.offset 4))) (let ((.cse290 (select .cse310 .cse311)) (.cse300 (select |c_old(#valid)| v_weq0_1)) (.cse318 (select |c_#valid| v_weq0_1)) (.cse316 (select |c_#valid| c_main_~list~5.offset)) (.cse298 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse319 (select |c_old(#valid)| 0)) (.cse314 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse315 (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (.cse317 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse301 (select .cse317 v_weq1_1)) (.cse288 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse289 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse315)) (.cse291 (= .cse314 .cse317)) (.cse292 (not (= 0 c_main_~list~5.base))) (.cse293 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse294 (= |c_main_#t~mem10.base| .cse319)) (.cse297 (select .cse314 .cse311)) (.cse295 (= |c_main_#t~mem10.offset| .cse298)) (.cse296 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse302 (= .cse310 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse303 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse304 (= 0 |c_main_#t~mem10.base|)) (.cse305 (= .cse319 .cse316)) (.cse306 (= .cse318 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse307 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse308 (= 1 .cse318)) (.cse309 (= (select .cse317 .cse311) .cse300)) (.cse312 (= .cse316 .cse290)) (.cse313 (= (select |c_#length| v_weq0_1) 8))) (or (let ((.cse299 (select .cse314 v_weq1_1))) (and .cse288 .cse289 (= .cse290 |c_main_#t~mem10.offset|) .cse291 .cse292 .cse293 .cse294 .cse295 .cse296 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse297 0) (= .cse298 .cse299) (= .cse300 .cse301) .cse302 (= c_main_~list~5.offset .cse297) (= .cse299 |c_#NULL.offset|) .cse303 .cse304 .cse305 .cse306 .cse307 .cse308 .cse309 (= |c_main_#t~malloc0.offset| (select .cse310 v_weq1_1)) (= .cse301 |c_#NULL.base|) (= .cse311 v_weq1_1) .cse312 .cse313)) (= .cse301 (select .cse315 v_weq1_1)) (not (= v_weq0_1 c_main_~list~5.base)) (and .cse288 .cse289 .cse291 .cse292 .cse293 (= .cse297 c_main_~list~5.offset) .cse294 (= |c_#NULL.base| .cse297) .cse295 .cse296 (= .cse300 |c_#NULL.base|) .cse302 .cse303 .cse304 (= .cse298 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse305 .cse306 .cse307 .cse308 .cse309 (= .cse290 v_weq1_1) .cse312 .cse313) (and (not (= v_weq1_1 .cse311)) (not (= v_weq1_1 0)))))))) (forall ((v_weq0_1 Int)) (let ((.cse329 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse320 (select .cse329 v_weq0_1))) (or (= .cse320 (select |c_#valid| v_weq0_1)) (let ((.cse325 (+ c_main_~list~5.offset 4)) (.cse328 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse323 (select .cse328 v_weq0_1)) (.cse322 (select |c_old(#valid)| 0)) (.cse326 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse327 (select .cse329 .cse325)) (.cse324 (select |c_#valid| c_main_~list~5.offset)) (.cse321 (select .cse328 .cse325))) (and (= .cse321 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (not (= c_main_~list~5.base 0)) (= .cse322 .cse323) (= .cse320 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse323 .cse324) (= .cse325 v_weq0_1) (= |c_main_#t~mem10.base| .cse322) (= .cse326 .cse320) (= |c_main_#t~mem10.offset| .cse326) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse327 0) (= c_main_~list~5.offset .cse327) (= .cse324 .cse321)))) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int)) (let ((.cse330 (select |c_#length| v_weq0_1))) (or (= .cse330 (select |c_old(#length)| v_weq0_1)) (let ((.cse341 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse333 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse338 (+ c_main_~list~5.offset 4))) (let ((.cse337 (select |c_#valid| v_weq0_1)) (.cse334 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse335 (select |c_old(#valid)| 0)) (.cse340 (select .cse333 .cse338)) (.cse332 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse339 (select |c_old(#valid)| v_weq0_1)) (.cse336 (select |c_#valid| c_main_~list~5.offset)) (.cse331 (select .cse341 .cse338))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse331 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= v_weq0_1 c_main_~list~5.base) (= 0 |c_main_#t~mem10.base|) (= .cse332 |c_#NULL.offset|) (= .cse333 .cse334) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (= c_main_~list~5.offset 0) (= .cse335 .cse336) (= .cse337 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 1 .cse337) (= (select .cse334 .cse338) .cse339) (= .cse340 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse335) (= |c_#NULL.base| .cse340) (not (= 0 |c_main_#t~malloc0.base|)) (= |c_main_#t~mem10.offset| .cse332) (= .cse339 |c_#NULL.base|) (= .cse341 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= .cse336 .cse331) (= .cse330 8))))))) (= .cse183 .cse342) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse348 (+ c_main_~list~5.offset 4))) (let ((.cse344 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse345 (select |c_old(#valid)| 0)) (.cse347 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse348)) (.cse346 (select |c_#valid| c_main_~list~5.offset)) (.cse343 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse348))) (and (= .cse343 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse344 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse344) (= c_main_~list~5.offset 0) (= .cse345 .cse346) (not (= 0 c_main_~list~5.base)) (= .cse347 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse345) (= |c_#NULL.base| .cse347) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse346 .cse343)))))) (= .cse342 .cse132) (= 1 (select |c_#valid| |c_main_#t~malloc0.base|)) (not (= |c_#valid| |c_old(#valid)|))))) is different from false [2018-01-21 10:54:02,730 WARN L1007 $PredicateComparison]: unable to prove that (let ((.cse349 (+ c_main_~list~5.offset 4))) (let ((.cse66 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse349)) (.cse86 (select |c_old(#valid)| 0)) (.cse183 (select |c_#valid| c_main_~list~5.offset)) (.cse342 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse349)) (.cse132 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (forall ((v_weq0_1 Int)) (let ((.cse15 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse14 (+ c_main_~list~5.offset 4))) (let ((.cse5 (select |c_#valid| c_main_~list~5.offset)) (.cse10 (select .cse15 .cse14)) (.cse16 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse2 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse4 (select |c_old(#valid)| 0))) (let ((.cse0 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse1 (= 0 |c_main_#t~mem10.base|)) (.cse3 (not (= c_main_~list~5.base 0))) (.cse6 (not (= 0 c_main_~list~5.base))) (.cse8 (= |c_main_#t~mem10.base| .cse4)) (.cse9 (= |c_main_#t~mem10.offset| .cse2)) (.cse7 (select .cse16 .cse14)) (.cse11 (= .cse5 .cse10)) (.cse13 (select .cse16 v_weq0_1))) (or (and .cse0 .cse1 (= .cse2 |c_#NULL.offset|) .cse3 (= c_main_~list~5.offset 0) (= .cse4 .cse5) .cse6 (= .cse7 c_main_~list~5.offset) .cse8 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse7) .cse9 (= .cse10 v_weq0_1) .cse11) (let ((.cse12 (select .cse15 v_weq0_1))) (and (= .cse10 |c_main_#t~mem10.offset|) .cse0 .cse1 .cse3 (= .cse4 .cse12) (= .cse13 |c_#NULL.offset|) .cse6 (= .cse12 .cse5) (= .cse14 v_weq0_1) .cse8 (= .cse2 .cse13) .cse9 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse7 0) (= c_main_~list~5.offset .cse7) .cse11)) (= .cse13 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (not (= c_main_~list~5.base 0)) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (or (not (= v_weq0_1 c_main_~list~5.base)) (and (not (= v_weq1_1 (+ c_main_~list~5.offset 4))) (not (= v_weq1_1 0))) (= (select (select |c_#memory_$Pointer$.base| v_weq0_1) v_weq1_1) (select (select |c_#memory_$Pointer$.offset| v_weq0_1) v_weq1_1)))) (forall ((v_weq0_1 Int)) (let ((.cse33 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse18 (+ c_main_~list~5.offset 4))) (let ((.cse26 (select |c_#valid| c_main_~list~5.offset)) (.cse31 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse23 (select |c_old(#valid)| 0)) (.cse32 (select .cse33 .cse18))) (let ((.cse17 (select .cse33 v_weq0_1)) (.cse19 (= .cse32 |c_main_#t~mem10.offset|)) (.cse20 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse21 (= 0 |c_main_#t~mem10.base|)) (.cse22 (not (= c_main_~list~5.base 0))) (.cse28 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse25 (not (= 0 c_main_~list~5.base))) (.cse27 (= |c_main_#t~mem10.base| .cse23)) (.cse29 (select .cse31 .cse18)) (.cse30 (= .cse26 .cse32))) (or (= .cse17 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 .cse18)) (not (= v_weq0_1 0))) (let ((.cse24 (select .cse31 v_weq0_1))) (and .cse19 .cse20 .cse21 .cse22 (= .cse23 .cse17) (= .cse24 |c_#NULL.offset|) .cse25 (= .cse17 .cse26) (= .cse18 v_weq0_1) .cse27 (= .cse28 .cse24) (= |c_main_#t~mem10.offset| .cse28) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse29 0) (= c_main_~list~5.offset .cse29) .cse30)) (and .cse19 .cse20 .cse21 (= .cse28 |c_#NULL.offset|) .cse22 (= v_weq0_1 .cse28) (= c_main_~list~5.offset 0) (= .cse23 .cse26) .cse25 (= .cse29 c_main_~list~5.offset) .cse27 (= |c_#NULL.base| .cse29) (= |c_main_#t~mem10.offset| v_weq0_1) .cse30)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse56 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse57 (+ c_main_~list~5.offset 4))) (let ((.cse36 (select .cse56 .cse57)) (.cse46 (select |c_old(#valid)| v_weq0_1)) (.cse61 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse64 (select |c_#valid| v_weq0_1)) (.cse62 (select |c_#valid| c_main_~list~5.offset)) (.cse44 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse65 (select |c_old(#valid)| 0)) (.cse60 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse63 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse47 (select .cse63 v_weq1_1)) (.cse34 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse35 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse37 (= .cse60 .cse63)) (.cse38 (not (= 0 c_main_~list~5.base))) (.cse39 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse40 (= |c_main_#t~mem10.base| .cse65)) (.cse43 (select .cse60 .cse57)) (.cse41 (= |c_main_#t~mem10.offset| .cse44)) (.cse42 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse48 (= .cse56 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse49 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse50 (= 0 |c_main_#t~mem10.base|)) (.cse51 (= .cse65 .cse62)) (.cse52 (= .cse64 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse53 (= .cse61 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse54 (= 1 .cse64)) (.cse55 (= (select .cse63 .cse57) .cse46)) (.cse58 (= .cse62 .cse36)) (.cse59 (= (select |c_#length| v_weq0_1) 8))) (or (let ((.cse45 (select .cse60 v_weq1_1))) (and .cse34 .cse35 (= .cse36 |c_main_#t~mem10.offset|) .cse37 .cse38 .cse39 .cse40 .cse41 .cse42 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse43 0) (= .cse44 .cse45) (= .cse46 .cse47) .cse48 (= c_main_~list~5.offset .cse43) (= .cse45 |c_#NULL.offset|) .cse49 .cse50 .cse51 .cse52 .cse53 .cse54 .cse55 (= |c_main_#t~malloc0.offset| (select .cse56 v_weq1_1)) (= .cse47 |c_#NULL.base|) (= .cse57 v_weq1_1) .cse58 .cse59)) (= (select .cse61 v_weq1_1) .cse47) (and .cse34 .cse35 .cse37 .cse38 .cse39 (= .cse43 c_main_~list~5.offset) .cse40 (= |c_#NULL.base| .cse43) .cse41 .cse42 (= .cse46 |c_#NULL.base|) .cse48 .cse49 .cse50 (= .cse44 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse51 .cse52 .cse53 .cse54 .cse55 (= .cse36 v_weq1_1) .cse58 .cse59)))))) (= .cse66 c_main_~list~5.offset) (forall ((v_weq0_1 Int)) (let ((.cse83 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse77 (+ c_main_~list~5.offset 4))) (let ((.cse76 (select |c_#valid| c_main_~list~5.offset)) (.cse84 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse72 (select |c_old(#valid)| 0)) (.cse85 (select .cse83 .cse77))) (let ((.cse81 (not (= v_weq0_1 0))) (.cse68 (= .cse85 |c_main_#t~mem10.offset|)) (.cse69 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse70 (= 0 |c_main_#t~mem10.base|)) (.cse71 (not (= c_main_~list~5.base 0))) (.cse79 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse74 (not (= 0 c_main_~list~5.base))) (.cse78 (= |c_main_#t~mem10.base| .cse72)) (.cse80 (select .cse84 .cse77)) (.cse82 (= .cse76 .cse85))) (or (let ((.cse75 (select .cse84 v_weq0_1))) (let ((.cse67 (select |c_old(#valid)| .cse75)) (.cse73 (select .cse83 v_weq0_1))) (and (= .cse67 |c_#NULL.offset|) .cse68 .cse69 .cse70 .cse71 (= .cse72 .cse73) .cse74 (= .cse75 .cse67) (= .cse73 .cse76) (= .cse77 v_weq0_1) .cse78 (= .cse79 .cse75) (= |c_main_#t~mem10.offset| .cse79) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse80 0) .cse81 (= c_main_~list~5.offset .cse80) .cse82))) (and (not (= v_weq0_1 .cse77)) .cse81) (and .cse68 .cse69 .cse70 (= .cse79 |c_#NULL.offset|) .cse71 (= v_weq0_1 .cse79) (= c_main_~list~5.offset 0) (= .cse72 .cse76) .cse74 (= .cse80 c_main_~list~5.offset) .cse78 (= |c_#NULL.base| .cse80) (= |c_main_#t~mem10.offset| v_weq0_1) .cse82) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (= |c_main_#t~mem10.base| .cse86) (= |c_#NULL.offset| |c_#NULL.base|) (= |c_#NULL.base| .cse66) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse92 (+ c_main_~list~5.offset 4))) (let ((.cse88 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse89 (select |c_old(#valid)| 0)) (.cse91 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse92)) (.cse90 (select |c_#valid| c_main_~list~5.offset)) (.cse87 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse92))) (and (= .cse87 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse88 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse88) (= c_main_~list~5.offset 0) (= .cse89 .cse90) (not (= 0 c_main_~list~5.base)) (= .cse91 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse89) (= |c_#NULL.base| .cse91) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse90 .cse87)))))) (not (= |c_#valid| |c_#length|)) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse98 (+ c_main_~list~5.offset 4))) (let ((.cse94 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse95 (select |c_old(#valid)| 0)) (.cse97 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse98)) (.cse96 (select |c_#valid| c_main_~list~5.offset)) (.cse93 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse98))) (and (= .cse93 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse94 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse94) (= c_main_~list~5.offset 0) (= .cse95 .cse96) (not (= 0 c_main_~list~5.base)) (= .cse97 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse95) (= |c_#NULL.base| .cse97) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse96 .cse93)))))) (forall ((v_weq0_1 Int)) (or (= (select |c_old(#valid)| v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse104 (+ c_main_~list~5.offset 4))) (let ((.cse100 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse101 (select |c_old(#valid)| 0)) (.cse103 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse104)) (.cse102 (select |c_#valid| c_main_~list~5.offset)) (.cse99 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse104))) (and (= .cse99 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse100 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse100) (= c_main_~list~5.offset 0) (= .cse101 .cse102) (not (= 0 c_main_~list~5.base)) (= .cse103 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse101) (= |c_#NULL.base| .cse103) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse102 .cse99)))))) (not |c_main_#t~short12|) (not (= |c_#length| |c_old(#valid)|)) (forall ((v_weq0_1 Int)) (let ((.cse113 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse105 (select .cse113 v_weq0_1))) (or (= .cse105 (select |c_#valid| v_weq0_1)) (let ((.cse110 (+ c_main_~list~5.offset 4)) (.cse114 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse107 (select |c_old(#valid)| 0)) (.cse108 (select .cse114 v_weq0_1)) (.cse111 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse112 (select .cse114 .cse110)) (.cse109 (select |c_#valid| c_main_~list~5.offset)) (.cse106 (select .cse113 .cse110))) (and (= .cse106 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (not (= c_main_~list~5.base 0)) (= .cse107 .cse105) (= .cse108 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse105 .cse109) (= .cse110 v_weq0_1) (= |c_main_#t~mem10.base| .cse107) (= .cse111 .cse108) (= |c_main_#t~mem10.offset| .cse111) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse112 0) (= c_main_~list~5.offset .cse112) (= .cse109 .cse106)))) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int)) (let ((.cse130 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse127 (+ c_main_~list~5.offset 4))) (let ((.cse120 (select |c_#valid| c_main_~list~5.offset)) (.cse125 (select .cse130 .cse127)) (.cse117 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse131 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse119 (select |c_old(#valid)| 0))) (let ((.cse115 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse116 (= 0 |c_main_#t~mem10.base|)) (.cse118 (not (= c_main_~list~5.base 0))) (.cse121 (not (= 0 c_main_~list~5.base))) (.cse123 (= |c_main_#t~mem10.base| .cse119)) (.cse128 (select .cse131 v_weq0_1)) (.cse124 (= |c_main_#t~mem10.offset| .cse117)) (.cse122 (select .cse131 .cse127)) (.cse126 (= .cse120 .cse125))) (or (and .cse115 .cse116 (= .cse117 |c_#NULL.offset|) .cse118 (= c_main_~list~5.offset 0) (= .cse119 .cse120) .cse121 (= .cse122 c_main_~list~5.offset) .cse123 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse122) .cse124 (= .cse125 v_weq0_1) .cse126) (and (not (= v_weq0_1 .cse127)) (not (= v_weq0_1 0))) (= .cse128 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1)) (let ((.cse129 (select .cse130 v_weq0_1))) (and (= .cse125 |c_main_#t~mem10.offset|) .cse115 .cse116 .cse118 (= .cse119 .cse129) (= .cse128 |c_#NULL.offset|) .cse121 (= .cse129 .cse120) (= .cse127 v_weq0_1) .cse123 (= .cse117 .cse128) .cse124 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse122 0) (= c_main_~list~5.offset .cse122) .cse126))))))) (= 0 |c_main_#t~mem10.base|) (= .cse132 |c_main_#t~mem10.offset|) (forall ((v_weq0_1 Int)) (let ((.cse134 (select |c_#valid| v_weq0_1)) (.cse133 (select |c_old(#valid)| v_weq0_1))) (or (= .cse133 .cse134) (let ((.cse141 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse136 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse143 (+ c_main_~list~5.offset 4))) (let ((.cse138 (select .cse136 .cse143)) (.cse140 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse139 (select |c_old(#valid)| 0)) (.cse137 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse142 (select |c_#valid| c_main_~list~5.offset)) (.cse135 (select .cse141 .cse143))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse135 |c_main_#t~mem10.offset|) (not (= c_main_~list~5.base 0)) (= .cse136 .cse137) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= .cse138 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse139) (= |c_#NULL.base| .cse138) (= |c_main_#t~mem10.offset| .cse140) (= v_weq0_1 |c_main_#t~malloc0.base|) (= .cse133 |c_#NULL.base|) (= .cse141 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse140 |c_#NULL.offset|) (= c_main_~list~5.offset 0) (= .cse139 .cse142) (= .cse134 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 1 .cse134) (= (select .cse137 .cse143) .cse133) (= .cse142 .cse135) (= (select |c_#length| v_weq0_1) 8))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse175 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse172 (+ c_main_~list~5.offset 4))) (let ((.cse163 (select .cse175 .cse172)) (.cse178 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse181 (select |c_#valid| v_weq0_1)) (.cse180 (select |c_#valid| c_main_~list~5.offset)) (.cse174 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse157 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse182 (select |c_old(#valid)| 0)) (.cse177 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse176 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse179 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse144 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse145 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse179)) (.cse146 (not (= c_main_~list~5.base 0))) (.cse147 (= .cse177 .cse176)) (.cse148 (not (= 0 c_main_~list~5.base))) (.cse149 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse151 (= |c_main_#t~mem10.base| .cse182)) (.cse152 (= |c_main_#t~mem10.offset| .cse157)) (.cse153 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse155 (= .cse175 .cse174)) (.cse150 (select .cse177 .cse172)) (.cse156 (= 0 |c_main_#t~mem10.base|)) (.cse162 (select .cse176 .cse172)) (.cse158 (= .cse182 .cse180)) (.cse154 (select |c_old(#valid)| v_weq0_1)) (.cse159 (= .cse181 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse160 (= .cse178 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse161 (= 1 .cse181)) (.cse164 (= .cse180 .cse163)) (.cse165 (= (select |c_#length| v_weq0_1) 8)) (.cse173 (not (= v_weq1_1 0)))) (or (and .cse144 .cse145 .cse146 .cse147 .cse148 .cse149 (= .cse150 c_main_~list~5.offset) .cse151 (= |c_#NULL.base| .cse150) .cse152 .cse153 (= .cse154 |c_#NULL.base|) .cse155 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse156 (= .cse157 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse158 .cse159 .cse160 .cse161 (= .cse162 .cse154) (= .cse163 v_weq1_1) .cse164 .cse165) (not (= v_weq0_1 c_main_~list~5.base)) (let ((.cse168 (select .cse177 v_weq1_1)) (.cse169 (select .cse176 v_weq1_1))) (let ((.cse171 (select |c_old(#valid)| .cse169)) (.cse167 (select |c_old(#valid)| .cse168)) (.cse166 (select .cse175 v_weq1_1)) (.cse170 (select .cse174 .cse172))) (and .cse144 .cse145 (= .cse163 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse166) .cse146 .cse147 (= |c_#NULL.base| .cse167) .cse148 .cse149 .cse151 .cse152 .cse153 (= .cse150 0) (= .cse157 .cse168) (= .cse154 .cse169) .cse155 (= c_main_~list~5.offset .cse150) (= .cse168 |c_#NULL.offset|) (= .cse170 |c_#NULL.base|) .cse156 (= .cse162 .cse171) .cse158 (= .cse171 .cse154) .cse159 (= .cse167 c_main_~list~5.offset) .cse160 .cse161 (= .cse166 |c_main_#t~malloc0.offset|) (= .cse172 v_weq1_1) .cse173 .cse164 (= .cse169 .cse170) .cse165))) (= (select .cse178 v_weq1_1) (select .cse179 v_weq1_1)) (and (not (= v_weq1_1 .cse172)) .cse173)))))) (= .cse86 .cse183) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse212 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse208 (+ c_main_~list~5.offset 4))) (let ((.cse188 (select .cse212 .cse208)) (.cse199 (select |c_old(#valid)| v_weq0_1)) (.cse215 (select |c_#valid| v_weq0_1)) (.cse214 (select |c_#valid| c_main_~list~5.offset)) (.cse184 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse197 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse216 (select |c_old(#valid)| 0)) (.cse213 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse211 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse185 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse186 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse187 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse185)) (.cse190 (= .cse213 .cse211)) (.cse191 (not (= 0 c_main_~list~5.base))) (.cse192 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse193 (= |c_main_#t~mem10.base| .cse216)) (.cse196 (select .cse213 .cse208)) (.cse194 (= |c_main_#t~mem10.offset| .cse197)) (.cse195 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse201 (= .cse212 .cse184)) (.cse202 (= 0 |c_main_#t~mem10.base|)) (.cse203 (= .cse216 .cse214)) (.cse204 (= .cse215 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse205 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse206 (= 1 .cse215)) (.cse207 (= (select .cse211 .cse208) .cse199)) (.cse209 (= .cse214 .cse188)) (.cse210 (= (select |c_#length| v_weq0_1) 8))) (or (= (select .cse184 v_weq1_1) (select .cse185 v_weq1_1)) (let ((.cse198 (select .cse213 v_weq1_1)) (.cse189 (select .cse212 v_weq1_1)) (.cse200 (select .cse211 v_weq1_1))) (and .cse186 .cse187 (= .cse188 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse189) .cse190 .cse191 .cse192 .cse193 .cse194 .cse195 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse196 0) (= .cse197 .cse198) (= .cse199 .cse200) .cse201 (= c_main_~list~5.offset .cse196) (= .cse198 |c_#NULL.offset|) .cse202 .cse203 .cse204 .cse205 .cse206 .cse207 (= .cse189 |c_main_#t~malloc0.offset|) (= .cse200 |c_#NULL.base|) (= .cse208 v_weq1_1) .cse209 .cse210)) (and .cse186 .cse187 .cse190 .cse191 .cse192 (= .cse196 c_main_~list~5.offset) .cse193 (= |c_#NULL.base| .cse196) .cse194 .cse195 (= .cse199 |c_#NULL.base|) .cse201 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse202 (= .cse197 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse203 .cse204 .cse205 .cse206 .cse207 (= .cse188 v_weq1_1) .cse209 .cse210)))))) (= |c_main_#t~mem10.offset| |c_#NULL.offset|) (forall ((v_weq0_1 Int)) (let ((.cse233 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse231 (+ c_main_~list~5.offset 4))) (let ((.cse222 (select |c_#valid| c_main_~list~5.offset)) (.cse227 (select .cse233 .cse231)) (.cse232 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse219 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse221 (select |c_old(#valid)| 0))) (let ((.cse217 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse218 (= 0 |c_main_#t~mem10.base|)) (.cse220 (not (= c_main_~list~5.base 0))) (.cse223 (not (= 0 c_main_~list~5.base))) (.cse225 (= |c_main_#t~mem10.base| .cse221)) (.cse226 (= |c_main_#t~mem10.offset| .cse219)) (.cse224 (select .cse232 .cse231)) (.cse228 (= .cse222 .cse227)) (.cse229 (select .cse233 v_weq0_1))) (or (and .cse217 .cse218 (= .cse219 |c_#NULL.offset|) .cse220 (= c_main_~list~5.offset 0) (= .cse221 .cse222) .cse223 (= .cse224 c_main_~list~5.offset) .cse225 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse224) .cse226 (= .cse227 v_weq0_1) .cse228) (let ((.cse230 (select .cse232 v_weq0_1))) (and (= .cse227 |c_main_#t~mem10.offset|) .cse217 .cse218 .cse220 (= .cse221 .cse229) (= .cse230 |c_#NULL.offset|) .cse223 (= .cse229 .cse222) (= .cse231 v_weq0_1) .cse225 (= .cse219 .cse230) .cse226 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse224 0) (= c_main_~list~5.offset .cse224) .cse228)) (= .cse229 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse263 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse256 (+ c_main_~list~5.offset 4))) (let ((.cse253 (select .cse263 .cse256)) (.cse244 (select |c_old(#valid)| v_weq0_1)) (.cse257 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse266 (select |c_#valid| v_weq0_1)) (.cse265 (select |c_#valid| c_main_~list~5.offset)) (.cse258 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse247 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse267 (select |c_old(#valid)| 0)) (.cse264 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse262 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse234 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse235 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse236 (not (= c_main_~list~5.base 0))) (.cse237 (= .cse264 .cse262)) (.cse238 (not (= 0 c_main_~list~5.base))) (.cse239 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse241 (= |c_main_#t~mem10.base| .cse267)) (.cse242 (= |c_main_#t~mem10.offset| .cse247)) (.cse243 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse245 (= .cse263 .cse258)) (.cse240 (select .cse264 .cse256)) (.cse246 (= 0 |c_main_#t~mem10.base|)) (.cse248 (= .cse267 .cse265)) (.cse249 (= .cse266 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse250 (= .cse257 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse251 (= 1 .cse266)) (.cse252 (= (select .cse262 .cse256) .cse244)) (.cse254 (= .cse265 .cse253)) (.cse255 (= (select |c_#length| v_weq0_1) 8))) (or (and .cse234 .cse235 .cse236 .cse237 .cse238 .cse239 (= .cse240 c_main_~list~5.offset) .cse241 (= |c_#NULL.base| .cse240) .cse242 .cse243 (= .cse244 |c_#NULL.base|) .cse245 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse246 (= .cse247 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse248 .cse249 .cse250 .cse251 .cse252 (= .cse253 v_weq1_1) .cse254 .cse255) (not (= v_weq0_1 c_main_~list~5.base)) (and (not (= v_weq1_1 .cse256)) (not (= v_weq1_1 0))) (= (select .cse257 v_weq1_1) (select .cse258 v_weq1_1)) (let ((.cse260 (select .cse264 v_weq1_1)) (.cse259 (select .cse263 v_weq1_1)) (.cse261 (select .cse262 v_weq1_1))) (and .cse234 .cse235 (= .cse253 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse259) .cse236 .cse237 .cse238 .cse239 .cse241 .cse242 .cse243 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse240 0) (= .cse247 .cse260) (= .cse244 .cse261) .cse245 (= c_main_~list~5.offset .cse240) (= .cse260 |c_#NULL.offset|) .cse246 .cse248 .cse249 .cse250 .cse251 .cse252 (= .cse259 |c_main_#t~malloc0.offset|) (= .cse261 |c_#NULL.base|) (= .cse256 v_weq1_1) .cse254 .cse255))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 (+ c_main_~list~5.offset 4))) (not (= v_weq0_1 0))))) (forall ((v_weq0_1 Int)) (let ((.cse277 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse271 (select .cse277 v_weq0_1))) (or (let ((.cse273 (+ c_main_~list~5.offset 4)) (.cse276 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse270 (select .cse276 v_weq0_1)) (.cse269 (select |c_old(#valid)| 0)) (.cse274 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse275 (select .cse277 .cse273)) (.cse272 (select |c_#valid| c_main_~list~5.offset)) (.cse268 (select .cse276 .cse273))) (and (= .cse268 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (not (= c_main_~list~5.base 0)) (= .cse269 .cse270) (= .cse271 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse270 .cse272) (= .cse273 v_weq0_1) (= |c_main_#t~mem10.base| .cse269) (= .cse274 .cse271) (= |c_main_#t~mem10.offset| .cse274) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse275 0) (= c_main_~list~5.offset .cse275) (= .cse272 .cse268)))) (not (= v_weq0_1 0)) (= .cse271 (select |c_old(#valid)| v_weq0_1)))))) (forall ((v_weq0_1 Int)) (let ((.cse286 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse278 (select .cse286 v_weq0_1))) (or (= .cse278 (select |c_old(#valid)| v_weq0_1)) (let ((.cse283 (+ c_main_~list~5.offset 4)) (.cse287 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse280 (select |c_old(#valid)| 0)) (.cse281 (select .cse287 v_weq0_1)) (.cse284 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse285 (select .cse287 .cse283)) (.cse282 (select |c_#valid| c_main_~list~5.offset)) (.cse279 (select .cse286 .cse283))) (and (= .cse279 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (not (= c_main_~list~5.base 0)) (= .cse280 .cse278) (= .cse281 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse278 .cse282) (= .cse283 v_weq0_1) (= |c_main_#t~mem10.base| .cse280) (= .cse284 .cse281) (= |c_main_#t~mem10.offset| .cse284) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse285 0) (= c_main_~list~5.offset .cse285) (= .cse282 .cse279)))) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse310 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse311 (+ c_main_~list~5.offset 4))) (let ((.cse290 (select .cse310 .cse311)) (.cse300 (select |c_old(#valid)| v_weq0_1)) (.cse318 (select |c_#valid| v_weq0_1)) (.cse316 (select |c_#valid| c_main_~list~5.offset)) (.cse298 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse319 (select |c_old(#valid)| 0)) (.cse314 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse315 (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (.cse317 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse301 (select .cse317 v_weq1_1)) (.cse288 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse289 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse315)) (.cse291 (= .cse314 .cse317)) (.cse292 (not (= 0 c_main_~list~5.base))) (.cse293 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse294 (= |c_main_#t~mem10.base| .cse319)) (.cse297 (select .cse314 .cse311)) (.cse295 (= |c_main_#t~mem10.offset| .cse298)) (.cse296 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse302 (= .cse310 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse303 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse304 (= 0 |c_main_#t~mem10.base|)) (.cse305 (= .cse319 .cse316)) (.cse306 (= .cse318 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse307 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse308 (= 1 .cse318)) (.cse309 (= (select .cse317 .cse311) .cse300)) (.cse312 (= .cse316 .cse290)) (.cse313 (= (select |c_#length| v_weq0_1) 8))) (or (let ((.cse299 (select .cse314 v_weq1_1))) (and .cse288 .cse289 (= .cse290 |c_main_#t~mem10.offset|) .cse291 .cse292 .cse293 .cse294 .cse295 .cse296 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse297 0) (= .cse298 .cse299) (= .cse300 .cse301) .cse302 (= c_main_~list~5.offset .cse297) (= .cse299 |c_#NULL.offset|) .cse303 .cse304 .cse305 .cse306 .cse307 .cse308 .cse309 (= |c_main_#t~malloc0.offset| (select .cse310 v_weq1_1)) (= .cse301 |c_#NULL.base|) (= .cse311 v_weq1_1) .cse312 .cse313)) (= .cse301 (select .cse315 v_weq1_1)) (not (= v_weq0_1 c_main_~list~5.base)) (and .cse288 .cse289 .cse291 .cse292 .cse293 (= .cse297 c_main_~list~5.offset) .cse294 (= |c_#NULL.base| .cse297) .cse295 .cse296 (= .cse300 |c_#NULL.base|) .cse302 .cse303 .cse304 (= .cse298 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse305 .cse306 .cse307 .cse308 .cse309 (= .cse290 v_weq1_1) .cse312 .cse313) (and (not (= v_weq1_1 .cse311)) (not (= v_weq1_1 0)))))))) (forall ((v_weq0_1 Int)) (let ((.cse329 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse320 (select .cse329 v_weq0_1))) (or (= .cse320 (select |c_#valid| v_weq0_1)) (let ((.cse325 (+ c_main_~list~5.offset 4)) (.cse328 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse323 (select .cse328 v_weq0_1)) (.cse322 (select |c_old(#valid)| 0)) (.cse326 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse327 (select .cse329 .cse325)) (.cse324 (select |c_#valid| c_main_~list~5.offset)) (.cse321 (select .cse328 .cse325))) (and (= .cse321 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (not (= c_main_~list~5.base 0)) (= .cse322 .cse323) (= .cse320 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse323 .cse324) (= .cse325 v_weq0_1) (= |c_main_#t~mem10.base| .cse322) (= .cse326 .cse320) (= |c_main_#t~mem10.offset| .cse326) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse327 0) (= c_main_~list~5.offset .cse327) (= .cse324 .cse321)))) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int)) (let ((.cse330 (select |c_#length| v_weq0_1))) (or (= .cse330 (select |c_old(#length)| v_weq0_1)) (let ((.cse341 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse333 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse338 (+ c_main_~list~5.offset 4))) (let ((.cse337 (select |c_#valid| v_weq0_1)) (.cse334 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse335 (select |c_old(#valid)| 0)) (.cse340 (select .cse333 .cse338)) (.cse332 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse339 (select |c_old(#valid)| v_weq0_1)) (.cse336 (select |c_#valid| c_main_~list~5.offset)) (.cse331 (select .cse341 .cse338))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse331 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= v_weq0_1 c_main_~list~5.base) (= 0 |c_main_#t~mem10.base|) (= .cse332 |c_#NULL.offset|) (= .cse333 .cse334) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (= c_main_~list~5.offset 0) (= .cse335 .cse336) (= .cse337 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 1 .cse337) (= (select .cse334 .cse338) .cse339) (= .cse340 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse335) (= |c_#NULL.base| .cse340) (not (= 0 |c_main_#t~malloc0.base|)) (= |c_main_#t~mem10.offset| .cse332) (= .cse339 |c_#NULL.base|) (= .cse341 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= .cse336 .cse331) (= .cse330 8))))))) (= .cse183 .cse342) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse348 (+ c_main_~list~5.offset 4))) (let ((.cse344 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse345 (select |c_old(#valid)| 0)) (.cse347 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse348)) (.cse346 (select |c_#valid| c_main_~list~5.offset)) (.cse343 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse348))) (and (= .cse343 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse344 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse344) (= c_main_~list~5.offset 0) (= .cse345 .cse346) (not (= 0 c_main_~list~5.base)) (= .cse347 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse345) (= |c_#NULL.base| .cse347) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse346 .cse343)))))) (= .cse342 .cse132) (= 1 (select |c_#valid| |c_main_#t~malloc0.base|)) (not (= |c_#valid| |c_old(#valid)|))))) is different from false Received shutdown request... [2018-01-21 10:54:03,289 WARN L1007 $PredicateComparison]: unable to prove that (let ((.cse349 (+ c_main_~list~5.offset 4))) (let ((.cse66 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse349)) (.cse86 (select |c_old(#valid)| 0)) (.cse183 (select |c_#valid| c_main_~list~5.offset)) (.cse342 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse349)) (.cse132 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (forall ((v_weq0_1 Int)) (let ((.cse15 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse14 (+ c_main_~list~5.offset 4))) (let ((.cse5 (select |c_#valid| c_main_~list~5.offset)) (.cse10 (select .cse15 .cse14)) (.cse16 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse2 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse4 (select |c_old(#valid)| 0))) (let ((.cse0 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse1 (= 0 |c_main_#t~mem10.base|)) (.cse3 (not (= c_main_~list~5.base 0))) (.cse6 (not (= 0 c_main_~list~5.base))) (.cse8 (= |c_main_#t~mem10.base| .cse4)) (.cse9 (= |c_main_#t~mem10.offset| .cse2)) (.cse7 (select .cse16 .cse14)) (.cse11 (= .cse5 .cse10)) (.cse13 (select .cse16 v_weq0_1))) (or (and .cse0 .cse1 (= .cse2 |c_#NULL.offset|) .cse3 (= c_main_~list~5.offset 0) (= .cse4 .cse5) .cse6 (= .cse7 c_main_~list~5.offset) .cse8 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse7) .cse9 (= .cse10 v_weq0_1) .cse11) (let ((.cse12 (select .cse15 v_weq0_1))) (and (= .cse10 |c_main_#t~mem10.offset|) .cse0 .cse1 .cse3 (= .cse4 .cse12) (= .cse13 |c_#NULL.offset|) .cse6 (= .cse12 .cse5) (= .cse14 v_weq0_1) .cse8 (= .cse2 .cse13) .cse9 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse7 0) (= c_main_~list~5.offset .cse7) .cse11)) (= .cse13 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (or (not (= v_weq0_1 c_main_~list~5.base)) (and (not (= v_weq1_1 (+ c_main_~list~5.offset 4))) (not (= v_weq1_1 0))) (= (select (select |c_#memory_$Pointer$.base| v_weq0_1) v_weq1_1) (select (select |c_#memory_$Pointer$.offset| v_weq0_1) v_weq1_1)))) (not (= 0 c_main_~list~5.base)) (forall ((v_weq0_1 Int)) (let ((.cse33 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse18 (+ c_main_~list~5.offset 4))) (let ((.cse26 (select |c_#valid| c_main_~list~5.offset)) (.cse31 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse23 (select |c_old(#valid)| 0)) (.cse32 (select .cse33 .cse18))) (let ((.cse17 (select .cse33 v_weq0_1)) (.cse19 (= .cse32 |c_main_#t~mem10.offset|)) (.cse20 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse21 (= 0 |c_main_#t~mem10.base|)) (.cse22 (not (= c_main_~list~5.base 0))) (.cse28 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse25 (not (= 0 c_main_~list~5.base))) (.cse27 (= |c_main_#t~mem10.base| .cse23)) (.cse29 (select .cse31 .cse18)) (.cse30 (= .cse26 .cse32))) (or (= .cse17 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 .cse18)) (not (= v_weq0_1 0))) (let ((.cse24 (select .cse31 v_weq0_1))) (and .cse19 .cse20 .cse21 .cse22 (= .cse23 .cse17) (= .cse24 |c_#NULL.offset|) .cse25 (= .cse17 .cse26) (= .cse18 v_weq0_1) .cse27 (= .cse28 .cse24) (= |c_main_#t~mem10.offset| .cse28) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse29 0) (= c_main_~list~5.offset .cse29) .cse30)) (and .cse19 .cse20 .cse21 (= .cse28 |c_#NULL.offset|) .cse22 (= v_weq0_1 .cse28) (= c_main_~list~5.offset 0) (= .cse23 .cse26) .cse25 (= .cse29 c_main_~list~5.offset) .cse27 (= |c_#NULL.base| .cse29) (= |c_main_#t~mem10.offset| v_weq0_1) .cse30)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse56 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse57 (+ c_main_~list~5.offset 4))) (let ((.cse36 (select .cse56 .cse57)) (.cse46 (select |c_old(#valid)| v_weq0_1)) (.cse61 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse64 (select |c_#valid| v_weq0_1)) (.cse62 (select |c_#valid| c_main_~list~5.offset)) (.cse44 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse65 (select |c_old(#valid)| 0)) (.cse60 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse63 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse47 (select .cse63 v_weq1_1)) (.cse34 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse35 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse37 (= .cse60 .cse63)) (.cse38 (not (= 0 c_main_~list~5.base))) (.cse39 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse40 (= |c_main_#t~mem10.base| .cse65)) (.cse43 (select .cse60 .cse57)) (.cse41 (= |c_main_#t~mem10.offset| .cse44)) (.cse42 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse48 (= .cse56 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse49 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse50 (= 0 |c_main_#t~mem10.base|)) (.cse51 (= .cse65 .cse62)) (.cse52 (= .cse64 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse53 (= .cse61 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse54 (= 1 .cse64)) (.cse55 (= (select .cse63 .cse57) .cse46)) (.cse58 (= .cse62 .cse36)) (.cse59 (= (select |c_#length| v_weq0_1) 8))) (or (let ((.cse45 (select .cse60 v_weq1_1))) (and .cse34 .cse35 (= .cse36 |c_main_#t~mem10.offset|) .cse37 .cse38 .cse39 .cse40 .cse41 .cse42 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse43 0) (= .cse44 .cse45) (= .cse46 .cse47) .cse48 (= c_main_~list~5.offset .cse43) (= .cse45 |c_#NULL.offset|) .cse49 .cse50 .cse51 .cse52 .cse53 .cse54 .cse55 (= |c_main_#t~malloc0.offset| (select .cse56 v_weq1_1)) (= .cse47 |c_#NULL.base|) (= .cse57 v_weq1_1) .cse58 .cse59)) (= (select .cse61 v_weq1_1) .cse47) (and .cse34 .cse35 .cse37 .cse38 .cse39 (= .cse43 c_main_~list~5.offset) .cse40 (= |c_#NULL.base| .cse43) .cse41 .cse42 (= .cse46 |c_#NULL.base|) .cse48 .cse49 .cse50 (= .cse44 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse51 .cse52 .cse53 .cse54 .cse55 (= .cse36 v_weq1_1) .cse58 .cse59)))))) (= .cse66 c_main_~list~5.offset) (forall ((v_weq0_1 Int)) (let ((.cse83 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse77 (+ c_main_~list~5.offset 4))) (let ((.cse76 (select |c_#valid| c_main_~list~5.offset)) (.cse84 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse72 (select |c_old(#valid)| 0)) (.cse85 (select .cse83 .cse77))) (let ((.cse81 (not (= v_weq0_1 0))) (.cse68 (= .cse85 |c_main_#t~mem10.offset|)) (.cse69 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse70 (= 0 |c_main_#t~mem10.base|)) (.cse71 (not (= c_main_~list~5.base 0))) (.cse79 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse74 (not (= 0 c_main_~list~5.base))) (.cse78 (= |c_main_#t~mem10.base| .cse72)) (.cse80 (select .cse84 .cse77)) (.cse82 (= .cse76 .cse85))) (or (let ((.cse75 (select .cse84 v_weq0_1))) (let ((.cse67 (select |c_old(#valid)| .cse75)) (.cse73 (select .cse83 v_weq0_1))) (and (= .cse67 |c_#NULL.offset|) .cse68 .cse69 .cse70 .cse71 (= .cse72 .cse73) .cse74 (= .cse75 .cse67) (= .cse73 .cse76) (= .cse77 v_weq0_1) .cse78 (= .cse79 .cse75) (= |c_main_#t~mem10.offset| .cse79) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse80 0) .cse81 (= c_main_~list~5.offset .cse80) .cse82))) (and (not (= v_weq0_1 .cse77)) .cse81) (and .cse68 .cse69 .cse70 (= .cse79 |c_#NULL.offset|) .cse71 (= v_weq0_1 .cse79) (= c_main_~list~5.offset 0) (= .cse72 .cse76) .cse74 (= .cse80 c_main_~list~5.offset) .cse78 (= |c_#NULL.base| .cse80) (= |c_main_#t~mem10.offset| v_weq0_1) .cse82) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (= |c_main_#t~mem10.base| .cse86) (= |c_#NULL.offset| |c_#NULL.base|) (= |c_#NULL.base| .cse66) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse92 (+ c_main_~list~5.offset 4))) (let ((.cse88 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse89 (select |c_old(#valid)| 0)) (.cse91 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse92)) (.cse90 (select |c_#valid| c_main_~list~5.offset)) (.cse87 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse92))) (and (= .cse87 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse88 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse88) (= c_main_~list~5.offset 0) (= .cse89 .cse90) (not (= 0 c_main_~list~5.base)) (= .cse91 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse89) (= |c_#NULL.base| .cse91) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse90 .cse87)))))) (not (= |c_#valid| |c_#length|)) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse98 (+ c_main_~list~5.offset 4))) (let ((.cse94 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse95 (select |c_old(#valid)| 0)) (.cse97 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse98)) (.cse96 (select |c_#valid| c_main_~list~5.offset)) (.cse93 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse98))) (and (= .cse93 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse94 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse94) (= c_main_~list~5.offset 0) (= .cse95 .cse96) (not (= 0 c_main_~list~5.base)) (= .cse97 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse95) (= |c_#NULL.base| .cse97) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse96 .cse93)))))) (forall ((v_weq0_1 Int)) (or (= (select |c_old(#valid)| v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse104 (+ c_main_~list~5.offset 4))) (let ((.cse100 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse101 (select |c_old(#valid)| 0)) (.cse103 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse104)) (.cse102 (select |c_#valid| c_main_~list~5.offset)) (.cse99 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse104))) (and (= .cse99 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse100 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse100) (= c_main_~list~5.offset 0) (= .cse101 .cse102) (not (= 0 c_main_~list~5.base)) (= .cse103 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse101) (= |c_#NULL.base| .cse103) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse102 .cse99)))))) (not |c_main_#t~short12|) (not (= |c_#length| |c_old(#valid)|)) (forall ((v_weq0_1 Int)) (let ((.cse113 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse105 (select .cse113 v_weq0_1))) (or (= .cse105 (select |c_#valid| v_weq0_1)) (let ((.cse110 (+ c_main_~list~5.offset 4)) (.cse114 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse107 (select |c_old(#valid)| 0)) (.cse108 (select .cse114 v_weq0_1)) (.cse111 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse112 (select .cse114 .cse110)) (.cse109 (select |c_#valid| c_main_~list~5.offset)) (.cse106 (select .cse113 .cse110))) (and (= .cse106 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (not (= c_main_~list~5.base 0)) (= .cse107 .cse105) (= .cse108 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse105 .cse109) (= .cse110 v_weq0_1) (= |c_main_#t~mem10.base| .cse107) (= .cse111 .cse108) (= |c_main_#t~mem10.offset| .cse111) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse112 0) (= c_main_~list~5.offset .cse112) (= .cse109 .cse106)))) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int)) (let ((.cse130 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse127 (+ c_main_~list~5.offset 4))) (let ((.cse120 (select |c_#valid| c_main_~list~5.offset)) (.cse125 (select .cse130 .cse127)) (.cse117 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse131 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse119 (select |c_old(#valid)| 0))) (let ((.cse115 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse116 (= 0 |c_main_#t~mem10.base|)) (.cse118 (not (= c_main_~list~5.base 0))) (.cse121 (not (= 0 c_main_~list~5.base))) (.cse123 (= |c_main_#t~mem10.base| .cse119)) (.cse128 (select .cse131 v_weq0_1)) (.cse124 (= |c_main_#t~mem10.offset| .cse117)) (.cse122 (select .cse131 .cse127)) (.cse126 (= .cse120 .cse125))) (or (and .cse115 .cse116 (= .cse117 |c_#NULL.offset|) .cse118 (= c_main_~list~5.offset 0) (= .cse119 .cse120) .cse121 (= .cse122 c_main_~list~5.offset) .cse123 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse122) .cse124 (= .cse125 v_weq0_1) .cse126) (and (not (= v_weq0_1 .cse127)) (not (= v_weq0_1 0))) (= .cse128 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1)) (let ((.cse129 (select .cse130 v_weq0_1))) (and (= .cse125 |c_main_#t~mem10.offset|) .cse115 .cse116 .cse118 (= .cse119 .cse129) (= .cse128 |c_#NULL.offset|) .cse121 (= .cse129 .cse120) (= .cse127 v_weq0_1) .cse123 (= .cse117 .cse128) .cse124 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse122 0) (= c_main_~list~5.offset .cse122) .cse126))))))) (= 0 |c_main_#t~mem10.base|) (= .cse132 |c_main_#t~mem10.offset|) (forall ((v_weq0_1 Int)) (let ((.cse134 (select |c_#valid| v_weq0_1)) (.cse133 (select |c_old(#valid)| v_weq0_1))) (or (= .cse133 .cse134) (let ((.cse141 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse136 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse143 (+ c_main_~list~5.offset 4))) (let ((.cse138 (select .cse136 .cse143)) (.cse140 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse139 (select |c_old(#valid)| 0)) (.cse137 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse142 (select |c_#valid| c_main_~list~5.offset)) (.cse135 (select .cse141 .cse143))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse135 |c_main_#t~mem10.offset|) (not (= c_main_~list~5.base 0)) (= .cse136 .cse137) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= .cse138 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse139) (= |c_#NULL.base| .cse138) (= |c_main_#t~mem10.offset| .cse140) (= v_weq0_1 |c_main_#t~malloc0.base|) (= .cse133 |c_#NULL.base|) (= .cse141 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse140 |c_#NULL.offset|) (= c_main_~list~5.offset 0) (= .cse139 .cse142) (= .cse134 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 1 .cse134) (= (select .cse137 .cse143) .cse133) (= .cse142 .cse135) (= (select |c_#length| v_weq0_1) 8))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse175 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse172 (+ c_main_~list~5.offset 4))) (let ((.cse163 (select .cse175 .cse172)) (.cse178 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse181 (select |c_#valid| v_weq0_1)) (.cse180 (select |c_#valid| c_main_~list~5.offset)) (.cse174 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse157 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse182 (select |c_old(#valid)| 0)) (.cse177 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse176 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse179 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse144 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse145 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse179)) (.cse146 (not (= c_main_~list~5.base 0))) (.cse147 (= .cse177 .cse176)) (.cse148 (not (= 0 c_main_~list~5.base))) (.cse149 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse151 (= |c_main_#t~mem10.base| .cse182)) (.cse152 (= |c_main_#t~mem10.offset| .cse157)) (.cse153 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse155 (= .cse175 .cse174)) (.cse150 (select .cse177 .cse172)) (.cse156 (= 0 |c_main_#t~mem10.base|)) (.cse162 (select .cse176 .cse172)) (.cse158 (= .cse182 .cse180)) (.cse154 (select |c_old(#valid)| v_weq0_1)) (.cse159 (= .cse181 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse160 (= .cse178 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse161 (= 1 .cse181)) (.cse164 (= .cse180 .cse163)) (.cse165 (= (select |c_#length| v_weq0_1) 8)) (.cse173 (not (= v_weq1_1 0)))) (or (and .cse144 .cse145 .cse146 .cse147 .cse148 .cse149 (= .cse150 c_main_~list~5.offset) .cse151 (= |c_#NULL.base| .cse150) .cse152 .cse153 (= .cse154 |c_#NULL.base|) .cse155 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse156 (= .cse157 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse158 .cse159 .cse160 .cse161 (= .cse162 .cse154) (= .cse163 v_weq1_1) .cse164 .cse165) (not (= v_weq0_1 c_main_~list~5.base)) (let ((.cse168 (select .cse177 v_weq1_1)) (.cse169 (select .cse176 v_weq1_1))) (let ((.cse171 (select |c_old(#valid)| .cse169)) (.cse167 (select |c_old(#valid)| .cse168)) (.cse166 (select .cse175 v_weq1_1)) (.cse170 (select .cse174 .cse172))) (and .cse144 .cse145 (= .cse163 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse166) .cse146 .cse147 (= |c_#NULL.base| .cse167) .cse148 .cse149 .cse151 .cse152 .cse153 (= .cse150 0) (= .cse157 .cse168) (= .cse154 .cse169) .cse155 (= c_main_~list~5.offset .cse150) (= .cse168 |c_#NULL.offset|) (= .cse170 |c_#NULL.base|) .cse156 (= .cse162 .cse171) .cse158 (= .cse171 .cse154) .cse159 (= .cse167 c_main_~list~5.offset) .cse160 .cse161 (= .cse166 |c_main_#t~malloc0.offset|) (= .cse172 v_weq1_1) .cse173 .cse164 (= .cse169 .cse170) .cse165))) (= (select .cse178 v_weq1_1) (select .cse179 v_weq1_1)) (and (not (= v_weq1_1 .cse172)) .cse173)))))) (= .cse86 .cse183) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse212 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse208 (+ c_main_~list~5.offset 4))) (let ((.cse188 (select .cse212 .cse208)) (.cse199 (select |c_old(#valid)| v_weq0_1)) (.cse215 (select |c_#valid| v_weq0_1)) (.cse214 (select |c_#valid| c_main_~list~5.offset)) (.cse184 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse197 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse216 (select |c_old(#valid)| 0)) (.cse213 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse211 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse185 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse186 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse187 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse185)) (.cse190 (= .cse213 .cse211)) (.cse191 (not (= 0 c_main_~list~5.base))) (.cse192 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse193 (= |c_main_#t~mem10.base| .cse216)) (.cse196 (select .cse213 .cse208)) (.cse194 (= |c_main_#t~mem10.offset| .cse197)) (.cse195 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse201 (= .cse212 .cse184)) (.cse202 (= 0 |c_main_#t~mem10.base|)) (.cse203 (= .cse216 .cse214)) (.cse204 (= .cse215 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse205 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse206 (= 1 .cse215)) (.cse207 (= (select .cse211 .cse208) .cse199)) (.cse209 (= .cse214 .cse188)) (.cse210 (= (select |c_#length| v_weq0_1) 8))) (or (= (select .cse184 v_weq1_1) (select .cse185 v_weq1_1)) (let ((.cse198 (select .cse213 v_weq1_1)) (.cse189 (select .cse212 v_weq1_1)) (.cse200 (select .cse211 v_weq1_1))) (and .cse186 .cse187 (= .cse188 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse189) .cse190 .cse191 .cse192 .cse193 .cse194 .cse195 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse196 0) (= .cse197 .cse198) (= .cse199 .cse200) .cse201 (= c_main_~list~5.offset .cse196) (= .cse198 |c_#NULL.offset|) .cse202 .cse203 .cse204 .cse205 .cse206 .cse207 (= .cse189 |c_main_#t~malloc0.offset|) (= .cse200 |c_#NULL.base|) (= .cse208 v_weq1_1) .cse209 .cse210)) (and .cse186 .cse187 .cse190 .cse191 .cse192 (= .cse196 c_main_~list~5.offset) .cse193 (= |c_#NULL.base| .cse196) .cse194 .cse195 (= .cse199 |c_#NULL.base|) .cse201 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse202 (= .cse197 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse203 .cse204 .cse205 .cse206 .cse207 (= .cse188 v_weq1_1) .cse209 .cse210)))))) (= |c_main_#t~mem10.offset| |c_#NULL.offset|) (forall ((v_weq0_1 Int)) (let ((.cse233 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse231 (+ c_main_~list~5.offset 4))) (let ((.cse222 (select |c_#valid| c_main_~list~5.offset)) (.cse227 (select .cse233 .cse231)) (.cse232 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse219 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse221 (select |c_old(#valid)| 0))) (let ((.cse217 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse218 (= 0 |c_main_#t~mem10.base|)) (.cse220 (not (= c_main_~list~5.base 0))) (.cse223 (not (= 0 c_main_~list~5.base))) (.cse225 (= |c_main_#t~mem10.base| .cse221)) (.cse226 (= |c_main_#t~mem10.offset| .cse219)) (.cse224 (select .cse232 .cse231)) (.cse228 (= .cse222 .cse227)) (.cse229 (select .cse233 v_weq0_1))) (or (and .cse217 .cse218 (= .cse219 |c_#NULL.offset|) .cse220 (= c_main_~list~5.offset 0) (= .cse221 .cse222) .cse223 (= .cse224 c_main_~list~5.offset) .cse225 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse224) .cse226 (= .cse227 v_weq0_1) .cse228) (let ((.cse230 (select .cse232 v_weq0_1))) (and (= .cse227 |c_main_#t~mem10.offset|) .cse217 .cse218 .cse220 (= .cse221 .cse229) (= .cse230 |c_#NULL.offset|) .cse223 (= .cse229 .cse222) (= .cse231 v_weq0_1) .cse225 (= .cse219 .cse230) .cse226 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse224 0) (= c_main_~list~5.offset .cse224) .cse228)) (= .cse229 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse263 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse256 (+ c_main_~list~5.offset 4))) (let ((.cse253 (select .cse263 .cse256)) (.cse244 (select |c_old(#valid)| v_weq0_1)) (.cse257 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse266 (select |c_#valid| v_weq0_1)) (.cse265 (select |c_#valid| c_main_~list~5.offset)) (.cse258 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse247 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse267 (select |c_old(#valid)| 0)) (.cse264 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse262 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse234 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse235 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse236 (not (= c_main_~list~5.base 0))) (.cse237 (= .cse264 .cse262)) (.cse238 (not (= 0 c_main_~list~5.base))) (.cse239 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse241 (= |c_main_#t~mem10.base| .cse267)) (.cse242 (= |c_main_#t~mem10.offset| .cse247)) (.cse243 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse245 (= .cse263 .cse258)) (.cse240 (select .cse264 .cse256)) (.cse246 (= 0 |c_main_#t~mem10.base|)) (.cse248 (= .cse267 .cse265)) (.cse249 (= .cse266 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse250 (= .cse257 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse251 (= 1 .cse266)) (.cse252 (= (select .cse262 .cse256) .cse244)) (.cse254 (= .cse265 .cse253)) (.cse255 (= (select |c_#length| v_weq0_1) 8))) (or (and .cse234 .cse235 .cse236 .cse237 .cse238 .cse239 (= .cse240 c_main_~list~5.offset) .cse241 (= |c_#NULL.base| .cse240) .cse242 .cse243 (= .cse244 |c_#NULL.base|) .cse245 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse246 (= .cse247 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse248 .cse249 .cse250 .cse251 .cse252 (= .cse253 v_weq1_1) .cse254 .cse255) (not (= v_weq0_1 c_main_~list~5.base)) (and (not (= v_weq1_1 .cse256)) (not (= v_weq1_1 0))) (= (select .cse257 v_weq1_1) (select .cse258 v_weq1_1)) (let ((.cse260 (select .cse264 v_weq1_1)) (.cse259 (select .cse263 v_weq1_1)) (.cse261 (select .cse262 v_weq1_1))) (and .cse234 .cse235 (= .cse253 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse259) .cse236 .cse237 .cse238 .cse239 .cse241 .cse242 .cse243 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse240 0) (= .cse247 .cse260) (= .cse244 .cse261) .cse245 (= c_main_~list~5.offset .cse240) (= .cse260 |c_#NULL.offset|) .cse246 .cse248 .cse249 .cse250 .cse251 .cse252 (= .cse259 |c_main_#t~malloc0.offset|) (= .cse261 |c_#NULL.base|) (= .cse256 v_weq1_1) .cse254 .cse255))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 (+ c_main_~list~5.offset 4))) (not (= v_weq0_1 0))))) (forall ((v_weq0_1 Int)) (let ((.cse277 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse271 (select .cse277 v_weq0_1))) (or (let ((.cse273 (+ c_main_~list~5.offset 4)) (.cse276 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse270 (select .cse276 v_weq0_1)) (.cse269 (select |c_old(#valid)| 0)) (.cse274 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse275 (select .cse277 .cse273)) (.cse272 (select |c_#valid| c_main_~list~5.offset)) (.cse268 (select .cse276 .cse273))) (and (= .cse268 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (not (= c_main_~list~5.base 0)) (= .cse269 .cse270) (= .cse271 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse270 .cse272) (= .cse273 v_weq0_1) (= |c_main_#t~mem10.base| .cse269) (= .cse274 .cse271) (= |c_main_#t~mem10.offset| .cse274) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse275 0) (= c_main_~list~5.offset .cse275) (= .cse272 .cse268)))) (not (= v_weq0_1 0)) (= .cse271 (select |c_old(#valid)| v_weq0_1)))))) (forall ((v_weq0_1 Int)) (let ((.cse286 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse278 (select .cse286 v_weq0_1))) (or (= .cse278 (select |c_old(#valid)| v_weq0_1)) (let ((.cse283 (+ c_main_~list~5.offset 4)) (.cse287 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse280 (select |c_old(#valid)| 0)) (.cse281 (select .cse287 v_weq0_1)) (.cse284 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse285 (select .cse287 .cse283)) (.cse282 (select |c_#valid| c_main_~list~5.offset)) (.cse279 (select .cse286 .cse283))) (and (= .cse279 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (not (= c_main_~list~5.base 0)) (= .cse280 .cse278) (= .cse281 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse278 .cse282) (= .cse283 v_weq0_1) (= |c_main_#t~mem10.base| .cse280) (= .cse284 .cse281) (= |c_main_#t~mem10.offset| .cse284) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse285 0) (= c_main_~list~5.offset .cse285) (= .cse282 .cse279)))) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse310 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse311 (+ c_main_~list~5.offset 4))) (let ((.cse290 (select .cse310 .cse311)) (.cse300 (select |c_old(#valid)| v_weq0_1)) (.cse318 (select |c_#valid| v_weq0_1)) (.cse316 (select |c_#valid| c_main_~list~5.offset)) (.cse298 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse319 (select |c_old(#valid)| 0)) (.cse314 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse315 (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (.cse317 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse301 (select .cse317 v_weq1_1)) (.cse288 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse289 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse315)) (.cse291 (= .cse314 .cse317)) (.cse292 (not (= 0 c_main_~list~5.base))) (.cse293 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse294 (= |c_main_#t~mem10.base| .cse319)) (.cse297 (select .cse314 .cse311)) (.cse295 (= |c_main_#t~mem10.offset| .cse298)) (.cse296 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse302 (= .cse310 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse303 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse304 (= 0 |c_main_#t~mem10.base|)) (.cse305 (= .cse319 .cse316)) (.cse306 (= .cse318 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse307 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse308 (= 1 .cse318)) (.cse309 (= (select .cse317 .cse311) .cse300)) (.cse312 (= .cse316 .cse290)) (.cse313 (= (select |c_#length| v_weq0_1) 8))) (or (let ((.cse299 (select .cse314 v_weq1_1))) (and .cse288 .cse289 (= .cse290 |c_main_#t~mem10.offset|) .cse291 .cse292 .cse293 .cse294 .cse295 .cse296 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse297 0) (= .cse298 .cse299) (= .cse300 .cse301) .cse302 (= c_main_~list~5.offset .cse297) (= .cse299 |c_#NULL.offset|) .cse303 .cse304 .cse305 .cse306 .cse307 .cse308 .cse309 (= |c_main_#t~malloc0.offset| (select .cse310 v_weq1_1)) (= .cse301 |c_#NULL.base|) (= .cse311 v_weq1_1) .cse312 .cse313)) (= .cse301 (select .cse315 v_weq1_1)) (not (= v_weq0_1 c_main_~list~5.base)) (and .cse288 .cse289 .cse291 .cse292 .cse293 (= .cse297 c_main_~list~5.offset) .cse294 (= |c_#NULL.base| .cse297) .cse295 .cse296 (= .cse300 |c_#NULL.base|) .cse302 .cse303 .cse304 (= .cse298 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse305 .cse306 .cse307 .cse308 .cse309 (= .cse290 v_weq1_1) .cse312 .cse313) (and (not (= v_weq1_1 .cse311)) (not (= v_weq1_1 0)))))))) (forall ((v_weq0_1 Int)) (let ((.cse329 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse320 (select .cse329 v_weq0_1))) (or (= .cse320 (select |c_#valid| v_weq0_1)) (let ((.cse325 (+ c_main_~list~5.offset 4)) (.cse328 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse323 (select .cse328 v_weq0_1)) (.cse322 (select |c_old(#valid)| 0)) (.cse326 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse327 (select .cse329 .cse325)) (.cse324 (select |c_#valid| c_main_~list~5.offset)) (.cse321 (select .cse328 .cse325))) (and (= .cse321 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (not (= c_main_~list~5.base 0)) (= .cse322 .cse323) (= .cse320 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse323 .cse324) (= .cse325 v_weq0_1) (= |c_main_#t~mem10.base| .cse322) (= .cse326 .cse320) (= |c_main_#t~mem10.offset| .cse326) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse327 0) (= c_main_~list~5.offset .cse327) (= .cse324 .cse321)))) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int)) (let ((.cse330 (select |c_#length| v_weq0_1))) (or (= .cse330 (select |c_old(#length)| v_weq0_1)) (let ((.cse341 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse333 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse338 (+ c_main_~list~5.offset 4))) (let ((.cse337 (select |c_#valid| v_weq0_1)) (.cse334 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse335 (select |c_old(#valid)| 0)) (.cse340 (select .cse333 .cse338)) (.cse332 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse339 (select |c_old(#valid)| v_weq0_1)) (.cse336 (select |c_#valid| c_main_~list~5.offset)) (.cse331 (select .cse341 .cse338))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse331 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= v_weq0_1 c_main_~list~5.base) (= 0 |c_main_#t~mem10.base|) (= .cse332 |c_#NULL.offset|) (= .cse333 .cse334) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (= c_main_~list~5.offset 0) (= .cse335 .cse336) (= .cse337 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 1 .cse337) (= (select .cse334 .cse338) .cse339) (= .cse340 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse335) (= |c_#NULL.base| .cse340) (not (= 0 |c_main_#t~malloc0.base|)) (= |c_main_#t~mem10.offset| .cse332) (= .cse339 |c_#NULL.base|) (= .cse341 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= .cse336 .cse331) (= .cse330 8))))))) (= .cse183 .cse342) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse348 (+ c_main_~list~5.offset 4))) (let ((.cse344 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse345 (select |c_old(#valid)| 0)) (.cse347 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse348)) (.cse346 (select |c_#valid| c_main_~list~5.offset)) (.cse343 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse348))) (and (= .cse343 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= 0 |c_main_#t~mem10.base|) (= .cse344 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse344) (= c_main_~list~5.offset 0) (= .cse345 .cse346) (not (= 0 c_main_~list~5.base)) (= .cse347 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse345) (= |c_#NULL.base| .cse347) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse346 .cse343)))))) (= .cse342 .cse132) (= 1 (select |c_#valid| |c_main_#t~malloc0.base|)) (not (= |c_#valid| |c_old(#valid)|))))) is different from false [2018-01-21 10:54:03,366 WARN L1007 $PredicateComparison]: unable to prove that (let ((.cse369 (+ c_main_~list~5.offset 4))) (let ((.cse199 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse369)) (.cse152 (select |c_old(#valid)| 0)) (.cse237 (select |c_#valid| c_main_~list~5.offset)) (.cse368 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse369)) (.cse236 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (forall ((v_weq0_1 Int)) (let ((.cse8 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse2 (select .cse8 v_weq0_1))) (or (let ((.cse5 (+ c_main_~list~5.offset 4)) (.cse9 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse1 (select |c_old(#valid)| 0)) (.cse3 (select .cse9 v_weq0_1)) (.cse6 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse7 (select .cse9 .cse5)) (.cse4 (select |c_#valid| c_main_~list~5.offset)) (.cse0 (select .cse8 .cse5))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse0 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse1 .cse2) (= .cse3 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse2 .cse4) (= .cse5 v_weq0_1) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= |c_main_#t~mem10.base| .cse1) (= .cse6 .cse3) (= |c_main_#t~mem10.offset| .cse6) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse7 0) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= c_main_~list~5.offset .cse7) (= .cse4 .cse0)))) (= .cse2 (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse36 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse37 (+ c_main_~list~5.offset 4))) (let ((.cse31 (select .cse36 .cse37)) (.cse39 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse42 (select |c_#valid| v_weq0_1)) (.cse41 (select |c_#valid| c_main_~list~5.offset)) (.cse20 (select |c_old(#valid)| v_weq0_1)) (.cse25 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse43 (select |c_old(#valid)| 0)) (.cse38 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse40 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse10 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse11 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse12 (= .cse38 .cse40)) (.cse13 (not (= 0 c_main_~list~5.base))) (.cse14 (= (select .cse40 .cse37) |c_main_#t~mem11.base|)) (.cse15 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse17 (= |c_main_#t~mem10.base| .cse43)) (.cse18 (= |c_main_#t~mem10.offset| .cse25)) (.cse19 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse21 (= .cse36 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse16 (select .cse38 .cse37)) (.cse22 (= |c_main_#t~mem11.base| .cse20)) (.cse23 (= 0 |c_main_#t~mem11.offset|)) (.cse24 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse26 (= .cse43 .cse41)) (.cse27 (= .cse42 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse28 (= .cse39 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse29 (= 1 .cse42)) (.cse30 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse32 (= .cse41 .cse31)) (.cse33 (= (select |c_#length| v_weq0_1) 8)) (.cse35 (select .cse40 v_weq1_1))) (or (and .cse10 .cse11 .cse12 .cse13 .cse14 .cse15 (= .cse16 c_main_~list~5.offset) .cse17 (= |c_#NULL.base| .cse16) .cse18 .cse19 (= .cse20 |c_#NULL.base|) .cse21 .cse22 .cse23 .cse24 (= .cse25 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse26 .cse27 .cse28 .cse29 .cse30 (= .cse31 v_weq1_1) .cse32 .cse33) (let ((.cse34 (select .cse38 v_weq1_1))) (and .cse10 .cse11 (= .cse31 |c_main_#t~mem10.offset|) .cse12 .cse13 .cse14 .cse15 .cse17 .cse18 .cse19 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse16 0) (= .cse25 .cse34) (= .cse20 .cse35) .cse21 (= c_main_~list~5.offset .cse16) (= .cse34 |c_#NULL.offset|) .cse22 .cse23 .cse24 .cse26 .cse27 .cse28 .cse29 (= |c_main_#t~malloc0.offset| (select .cse36 v_weq1_1)) (= .cse35 |c_#NULL.base|) (= .cse37 v_weq1_1) .cse30 .cse32 .cse33)) (= (select .cse39 v_weq1_1) .cse35)))))) (forall ((v_weq0_1 Int)) (let ((.cse61 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse53 (+ c_main_~list~5.offset 4))) (let ((.cse52 (select |c_#valid| c_main_~list~5.offset)) (.cse45 (select .cse61 .cse53)) (.cse56 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse62 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse48 (select |c_old(#valid)| 0))) (let ((.cse44 (= 0 |c_main_#t~mem11.offset|)) (.cse46 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse47 (not (= c_main_~list~5.base 0))) (.cse51 (not (= 0 c_main_~list~5.base))) (.cse54 (= |c_main_#t~mem11.base| |c_#NULL.base|)) (.cse55 (= |c_main_#t~mem10.base| .cse48)) (.cse58 (select .cse62 .cse53)) (.cse57 (= |c_main_#t~mem10.offset| .cse56)) (.cse59 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse60 (= .cse52 .cse45)) (.cse50 (select .cse62 v_weq0_1))) (or (let ((.cse49 (select .cse61 v_weq0_1))) (and .cse44 (= .cse45 |c_main_#t~mem10.offset|) .cse46 .cse47 (= .cse48 .cse49) (= .cse50 |c_#NULL.offset|) .cse51 (= .cse49 .cse52) (= .cse53 v_weq0_1) .cse54 .cse55 (= .cse56 .cse50) .cse57 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse58 0) .cse59 (= c_main_~list~5.offset .cse58) .cse60)) (and .cse44 .cse46 (= .cse56 |c_#NULL.offset|) .cse47 (= c_main_~list~5.offset 0) (= .cse48 .cse52) .cse51 .cse54 (= .cse58 c_main_~list~5.offset) .cse55 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse58) .cse57 .cse59 (= .cse45 v_weq0_1) .cse60) (and (not (= v_weq0_1 .cse53)) (not (= v_weq0_1 0))) (= .cse50 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse93 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse91 (+ c_main_~list~5.offset 4))) (let ((.cse85 (select .cse93 .cse91)) (.cse96 (select |c_#valid| v_weq0_1)) (.cse95 (select |c_#valid| c_main_~list~5.offset)) (.cse75 (select |c_old(#valid)| v_weq0_1)) (.cse63 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse79 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse97 (select |c_old(#valid)| 0)) (.cse94 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse92 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse64 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse65 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse66 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse64)) (.cse67 (= .cse94 .cse92)) (.cse68 (not (= 0 c_main_~list~5.base))) (.cse69 (= (select .cse92 .cse91) |c_main_#t~mem11.base|)) (.cse70 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse72 (= |c_main_#t~mem10.base| .cse97)) (.cse73 (= |c_main_#t~mem10.offset| .cse79)) (.cse74 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse76 (= .cse93 .cse63)) (.cse71 (select .cse94 .cse91)) (.cse77 (= |c_main_#t~mem11.base| .cse75)) (.cse78 (= 0 |c_main_#t~mem11.offset|)) (.cse80 (= .cse97 .cse95)) (.cse81 (= .cse96 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse82 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse83 (= 1 .cse96)) (.cse84 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse86 (= .cse95 .cse85)) (.cse87 (= (select |c_#length| v_weq0_1) 8))) (or (= (select .cse63 v_weq1_1) (select .cse64 v_weq1_1)) (and .cse65 .cse66 .cse67 .cse68 .cse69 .cse70 (= .cse71 c_main_~list~5.offset) .cse72 (= |c_#NULL.base| .cse71) .cse73 .cse74 (= .cse75 |c_#NULL.base|) .cse76 .cse77 .cse78 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse79 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse80 .cse81 .cse82 .cse83 .cse84 (= .cse85 v_weq1_1) .cse86 .cse87) (let ((.cse89 (select .cse94 v_weq1_1)) (.cse88 (select .cse93 v_weq1_1)) (.cse90 (select .cse92 v_weq1_1))) (and .cse65 .cse66 (= .cse85 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse88) .cse67 .cse68 .cse69 .cse70 .cse72 .cse73 .cse74 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse71 0) (= .cse79 .cse89) (= .cse75 .cse90) .cse76 (= c_main_~list~5.offset .cse71) (= .cse89 |c_#NULL.offset|) .cse77 .cse78 .cse80 .cse81 .cse82 .cse83 (= .cse88 |c_main_#t~malloc0.offset|) (= .cse90 |c_#NULL.base|) (= .cse91 v_weq1_1) .cse84 .cse86 .cse87))))))) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (forall ((v_weq0_1 Int)) (let ((.cse106 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse100 (select .cse106 v_weq0_1))) (or (let ((.cse103 (+ c_main_~list~5.offset 4)) (.cse107 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse99 (select |c_old(#valid)| 0)) (.cse101 (select .cse107 v_weq0_1)) (.cse104 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse105 (select .cse107 .cse103)) (.cse102 (select |c_#valid| c_main_~list~5.offset)) (.cse98 (select .cse106 .cse103))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse98 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse99 .cse100) (= .cse101 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse100 .cse102) (= .cse103 v_weq0_1) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= |c_main_#t~mem10.base| .cse99) (= .cse104 .cse101) (= |c_main_#t~mem10.offset| .cse104) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse105 0) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= c_main_~list~5.offset .cse105) (= .cse102 .cse98)))) (= .cse100 (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (or (not (= v_weq0_1 c_main_~list~5.base)) (and (not (= v_weq1_1 (+ c_main_~list~5.offset 4))) (not (= v_weq1_1 0))) (= (select (select |c_#memory_$Pointer$.base| v_weq0_1) v_weq1_1) (select (select |c_#memory_$Pointer$.offset| v_weq0_1) v_weq1_1)))) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~mem11.base| |c_#NULL.base|) (forall ((v_weq0_1 Int)) (let ((.cse117 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse111 (select .cse117 v_weq0_1))) (or (let ((.cse113 (+ c_main_~list~5.offset 4)) (.cse116 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse110 (select .cse116 v_weq0_1)) (.cse109 (select |c_old(#valid)| 0)) (.cse114 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse115 (select .cse117 .cse113)) (.cse112 (select |c_#valid| c_main_~list~5.offset)) (.cse108 (select .cse116 .cse113))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse108 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse109 .cse110) (= .cse111 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse110 .cse112) (= .cse113 v_weq0_1) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= |c_main_#t~mem10.base| .cse109) (= .cse114 .cse111) (= |c_main_#t~mem10.offset| .cse114) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse115 0) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= c_main_~list~5.offset .cse115) (= .cse112 .cse108)))) (not (= v_weq0_1 0)) (= .cse111 (select |c_old(#valid)| v_weq0_1)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse144 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse145 (+ c_main_~list~5.offset 4))) (let ((.cse139 (select .cse144 .cse145)) (.cse150 (select |c_#valid| v_weq0_1)) (.cse149 (select |c_#valid| c_main_~list~5.offset)) (.cse128 (select |c_old(#valid)| v_weq0_1)) (.cse133 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse151 (select |c_old(#valid)| 0)) (.cse146 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse148 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse147 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse118 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse119 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse147)) (.cse120 (= .cse146 .cse148)) (.cse121 (not (= 0 c_main_~list~5.base))) (.cse122 (= (select .cse148 .cse145) |c_main_#t~mem11.base|)) (.cse123 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse125 (= |c_main_#t~mem10.base| .cse151)) (.cse126 (= |c_main_#t~mem10.offset| .cse133)) (.cse127 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse129 (= .cse144 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse124 (select .cse146 .cse145)) (.cse130 (= |c_main_#t~mem11.base| .cse128)) (.cse131 (= 0 |c_main_#t~mem11.offset|)) (.cse132 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse134 (= .cse151 .cse149)) (.cse135 (= .cse150 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse136 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse137 (= 1 .cse150)) (.cse138 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse140 (= .cse149 .cse139)) (.cse141 (= (select |c_#length| v_weq0_1) 8)) (.cse143 (select .cse148 v_weq1_1))) (or (and .cse118 .cse119 .cse120 .cse121 .cse122 .cse123 (= .cse124 c_main_~list~5.offset) .cse125 (= |c_#NULL.base| .cse124) .cse126 .cse127 (= .cse128 |c_#NULL.base|) .cse129 .cse130 .cse131 .cse132 (= .cse133 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse134 .cse135 .cse136 .cse137 .cse138 (= .cse139 v_weq1_1) .cse140 .cse141) (let ((.cse142 (select .cse146 v_weq1_1))) (and .cse118 .cse119 (= .cse139 |c_main_#t~mem10.offset|) .cse120 .cse121 .cse122 .cse123 .cse125 .cse126 .cse127 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse124 0) (= .cse133 .cse142) (= .cse128 .cse143) .cse129 (= c_main_~list~5.offset .cse124) (= .cse142 |c_#NULL.offset|) .cse130 .cse131 .cse132 .cse134 .cse135 .cse136 .cse137 (= |c_main_#t~malloc0.offset| (select .cse144 v_weq1_1)) (= .cse143 |c_#NULL.base|) (= .cse145 v_weq1_1) .cse138 .cse140 .cse141)) (= .cse143 (select .cse147 v_weq1_1)) (not (= v_weq0_1 c_main_~list~5.base)) (and (not (= v_weq1_1 .cse145)) (not (= v_weq1_1 0)))))))) (= |c_main_#t~mem10.base| .cse152) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse184 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse153 (+ c_main_~list~5.offset 4))) (let ((.cse158 (select .cse184 .cse153)) (.cse154 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse187 (select |c_#valid| v_weq0_1)) (.cse186 (select |c_#valid| c_main_~list~5.offset)) (.cse171 (select |c_old(#valid)| v_weq0_1)) (.cse155 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse169 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse188 (select |c_old(#valid)| 0)) (.cse185 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse183 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse156 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse157 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse160 (not (= c_main_~list~5.base 0))) (.cse161 (= .cse185 .cse183)) (.cse162 (not (= 0 c_main_~list~5.base))) (.cse163 (= (select .cse183 .cse153) |c_main_#t~mem11.base|)) (.cse164 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse165 (= |c_main_#t~mem10.base| .cse188)) (.cse168 (select .cse185 .cse153)) (.cse166 (= |c_main_#t~mem10.offset| .cse169)) (.cse167 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse173 (= .cse184 .cse155)) (.cse174 (= |c_main_#t~mem11.base| .cse171)) (.cse175 (= 0 |c_main_#t~mem11.offset|)) (.cse176 (= .cse188 .cse186)) (.cse177 (= .cse187 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse178 (= .cse154 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse179 (= 1 .cse187)) (.cse180 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse181 (= .cse186 .cse158)) (.cse182 (= (select |c_#length| v_weq0_1) 8))) (or (not (= v_weq0_1 c_main_~list~5.base)) (and (not (= v_weq1_1 .cse153)) (not (= v_weq1_1 0))) (= (select .cse154 v_weq1_1) (select .cse155 v_weq1_1)) (let ((.cse170 (select .cse185 v_weq1_1)) (.cse159 (select .cse184 v_weq1_1)) (.cse172 (select .cse183 v_weq1_1))) (and .cse156 .cse157 (= .cse158 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse159) .cse160 .cse161 .cse162 .cse163 .cse164 .cse165 .cse166 .cse167 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse168 0) (= .cse169 .cse170) (= .cse171 .cse172) .cse173 (= c_main_~list~5.offset .cse168) (= .cse170 |c_#NULL.offset|) .cse174 .cse175 .cse176 .cse177 .cse178 .cse179 (= .cse159 |c_main_#t~malloc0.offset|) (= .cse172 |c_#NULL.base|) (= .cse153 v_weq1_1) .cse180 .cse181 .cse182)) (and .cse156 .cse157 .cse160 .cse161 .cse162 .cse163 .cse164 (= .cse168 c_main_~list~5.offset) .cse165 (= |c_#NULL.base| .cse168) .cse166 .cse167 (= .cse171 |c_#NULL.base|) .cse173 .cse174 .cse175 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse169 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse176 .cse177 .cse178 .cse179 .cse180 (= .cse158 v_weq1_1) .cse181 .cse182)))))) (not (= |c_#valid| |c_#length|)) (forall ((v_weq0_1 Int)) (let ((.cse198 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse192 (select .cse198 v_weq0_1))) (or (let ((.cse194 (+ c_main_~list~5.offset 4)) (.cse197 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse191 (select .cse197 v_weq0_1)) (.cse190 (select |c_old(#valid)| 0)) (.cse195 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse196 (select .cse198 .cse194)) (.cse193 (select |c_#valid| c_main_~list~5.offset)) (.cse189 (select .cse197 .cse194))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse189 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse190 .cse191) (= .cse192 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse191 .cse193) (= .cse194 v_weq0_1) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= |c_main_#t~mem10.base| .cse190) (= .cse195 .cse192) (= |c_main_#t~mem10.offset| .cse195) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse196 0) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= c_main_~list~5.offset .cse196) (= .cse193 .cse189)))) (= .cse192 (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))))) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse199 0) (= c_main_~list~5.offset .cse199) (not |c_main_#t~short12|) (not (= |c_#length| |c_old(#valid)|)) (forall ((v_weq0_1 Int)) (or (let ((.cse205 (+ c_main_~list~5.offset 4))) (let ((.cse201 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse202 (select |c_old(#valid)| 0)) (.cse204 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse205)) (.cse203 (select |c_#valid| c_main_~list~5.offset)) (.cse200 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse205))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse200 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse201 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse201) (= c_main_~list~5.offset 0) (= .cse202 .cse203) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= .cse204 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse202) (= |c_#NULL.base| .cse204) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse203 .cse200)))) (= (select |c_old(#valid)| v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)))) (= 0 |c_main_#t~mem11.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (forall ((v_weq0_1 Int)) (let ((.cse206 (select |c_old(#valid)| v_weq0_1)) (.cse207 (select |c_#valid| v_weq0_1))) (or (= .cse206 .cse207) (let ((.cse215 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse209 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse211 (+ c_main_~list~5.offset 4))) (let ((.cse210 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse212 (select .cse209 .cse211)) (.cse214 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse213 (select |c_old(#valid)| 0)) (.cse216 (select |c_#valid| c_main_~list~5.offset)) (.cse208 (select .cse215 .cse211))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse208 |c_main_#t~mem10.offset|) (not (= c_main_~list~5.base 0)) (= .cse209 .cse210) (not (= 0 c_main_~list~5.base)) (= (select .cse210 .cse211) |c_main_#t~mem11.base|) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= .cse212 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse213) (= |c_#NULL.base| .cse212) (= |c_main_#t~mem10.offset| .cse214) (= v_weq0_1 |c_main_#t~malloc0.base|) (= .cse206 |c_#NULL.base|) (= .cse215 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= |c_main_#t~mem11.base| .cse206) (= 0 |c_main_#t~mem11.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse214 |c_#NULL.offset|) (= c_main_~list~5.offset 0) (= .cse213 .cse216) (= .cse207 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 1 .cse207) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= .cse216 .cse208) (= (select |c_#length| v_weq0_1) 8))))))) (forall ((v_weq0_1 Int)) (let ((.cse235 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse226 (+ c_main_~list~5.offset 4))) (let ((.cse225 (select |c_#valid| c_main_~list~5.offset)) (.cse218 (select .cse235 .cse226)) (.cse229 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse234 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse221 (select |c_old(#valid)| 0))) (let ((.cse217 (= 0 |c_main_#t~mem11.offset|)) (.cse219 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse220 (not (= c_main_~list~5.base 0))) (.cse224 (not (= 0 c_main_~list~5.base))) (.cse227 (= |c_main_#t~mem11.base| |c_#NULL.base|)) (.cse228 (= |c_main_#t~mem10.base| .cse221)) (.cse231 (select .cse234 .cse226)) (.cse230 (= |c_main_#t~mem10.offset| .cse229)) (.cse232 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse233 (= .cse225 .cse218)) (.cse222 (select .cse235 v_weq0_1))) (or (let ((.cse223 (select .cse234 v_weq0_1))) (and .cse217 (= .cse218 |c_main_#t~mem10.offset|) .cse219 .cse220 (= .cse221 .cse222) (= .cse223 |c_#NULL.offset|) .cse224 (= .cse222 .cse225) (= .cse226 v_weq0_1) .cse227 .cse228 (= .cse229 .cse223) .cse230 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse231 0) .cse232 (= c_main_~list~5.offset .cse231) .cse233)) (and .cse217 .cse219 (= .cse229 |c_#NULL.offset|) .cse220 (= c_main_~list~5.offset 0) (= .cse221 .cse225) .cse224 .cse227 (= .cse231 c_main_~list~5.offset) .cse228 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse231) .cse230 .cse232 (= .cse218 v_weq0_1) .cse233) (= .cse222 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1))))))) (= .cse236 |c_main_#t~mem10.offset|) (= .cse152 .cse237) (forall ((v_weq0_1 Int)) (or (let ((.cse243 (+ c_main_~list~5.offset 4))) (let ((.cse239 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse240 (select |c_old(#valid)| 0)) (.cse242 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse243)) (.cse241 (select |c_#valid| c_main_~list~5.offset)) (.cse238 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse243))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse238 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse239 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse239) (= c_main_~list~5.offset 0) (= .cse240 .cse241) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= .cse242 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse240) (= |c_#NULL.base| .cse242) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse241 .cse238)))) (= (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))) (= |c_main_#t~mem10.offset| |c_#NULL.offset|) (forall ((v_weq0_1 Int)) (or (let ((.cse249 (+ c_main_~list~5.offset 4))) (let ((.cse245 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse246 (select |c_old(#valid)| 0)) (.cse248 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse249)) (.cse247 (select |c_#valid| c_main_~list~5.offset)) (.cse244 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse249))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse244 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse245 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse245) (= c_main_~list~5.offset 0) (= .cse246 .cse247) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= .cse248 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse246) (= |c_#NULL.base| .cse248) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse247 .cse244)))) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse283 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse277 (+ c_main_~list~5.offset 4))) (let ((.cse252 (select .cse283 .cse277)) (.cse286 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse289 (select |c_#valid| v_weq0_1)) (.cse288 (select |c_#valid| c_main_~list~5.offset)) (.cse265 (select |c_old(#valid)| v_weq0_1)) (.cse282 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse263 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse290 (select |c_old(#valid)| 0)) (.cse285 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse284 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse287 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse278 (not (= v_weq1_1 0))) (.cse250 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse251 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse287)) (.cse254 (not (= c_main_~list~5.base 0))) (.cse255 (= .cse285 .cse284)) (.cse257 (not (= 0 c_main_~list~5.base))) (.cse272 (select .cse284 .cse277)) (.cse258 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse259 (= |c_main_#t~mem10.base| .cse290)) (.cse262 (select .cse285 .cse277)) (.cse260 (= |c_main_#t~mem10.offset| .cse263)) (.cse261 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse267 (= .cse283 .cse282)) (.cse269 (= |c_main_#t~mem11.base| .cse265)) (.cse270 (= 0 |c_main_#t~mem11.offset|)) (.cse273 (= .cse290 .cse288)) (.cse274 (= .cse289 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse275 (= .cse286 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse276 (= 1 .cse289)) (.cse279 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse280 (= .cse288 .cse252)) (.cse281 (= (select |c_#length| v_weq0_1) 8))) (or (not (= v_weq0_1 c_main_~list~5.base)) (let ((.cse264 (select .cse285 v_weq1_1)) (.cse266 (select .cse284 v_weq1_1))) (let ((.cse271 (select |c_old(#valid)| .cse266)) (.cse256 (select |c_old(#valid)| .cse264)) (.cse253 (select .cse283 v_weq1_1)) (.cse268 (select .cse282 .cse277))) (and .cse250 .cse251 (= .cse252 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse253) .cse254 .cse255 (= |c_#NULL.base| .cse256) .cse257 .cse258 .cse259 .cse260 .cse261 (= .cse262 0) (= .cse263 .cse264) (= .cse265 .cse266) .cse267 (= c_main_~list~5.offset .cse262) (= .cse264 |c_#NULL.offset|) (= .cse268 |c_#NULL.base|) .cse269 .cse270 (= .cse271 |c_main_#t~mem11.base|) (= .cse272 .cse271) .cse273 .cse274 (= .cse256 c_main_~list~5.offset) .cse275 .cse276 (= .cse253 |c_main_#t~malloc0.offset|) (= .cse277 v_weq1_1) .cse278 .cse279 .cse280 (= .cse266 .cse268) .cse281))) (= (select .cse286 v_weq1_1) (select .cse287 v_weq1_1)) (and (not (= v_weq1_1 .cse277)) .cse278) (and .cse250 .cse251 .cse254 .cse255 .cse257 (= .cse272 |c_main_#t~mem11.base|) .cse258 (= .cse262 c_main_~list~5.offset) .cse259 (= |c_#NULL.base| .cse262) .cse260 .cse261 (= .cse265 |c_#NULL.base|) .cse267 .cse269 .cse270 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse263 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse273 .cse274 .cse275 .cse276 .cse279 (= .cse252 v_weq1_1) .cse280 .cse281)))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 (+ c_main_~list~5.offset 4))) (not (= v_weq0_1 0))))) (forall ((v_weq0_1 Int)) (let ((.cse302 (select |c_#length| v_weq0_1))) (or (let ((.cse299 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse292 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse294 (+ c_main_~list~5.offset 4))) (let ((.cse293 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse295 (select .cse292 .cse294)) (.cse298 (select |c_old(#valid)| v_weq0_1)) (.cse297 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse296 (select |c_old(#valid)| 0)) (.cse301 (select |c_#valid| v_weq0_1)) (.cse300 (select |c_#valid| c_main_~list~5.offset)) (.cse291 (select .cse299 .cse294))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse291 |c_main_#t~mem10.offset|) (= v_weq0_1 c_main_~list~5.base) (= .cse292 .cse293) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (= (select .cse293 .cse294) |c_main_#t~mem11.base|) (= .cse295 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse296) (= |c_#NULL.base| .cse295) (not (= 0 |c_main_#t~malloc0.base|)) (= |c_main_#t~mem10.offset| .cse297) (= .cse298 |c_#NULL.base|) (= .cse299 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= |c_main_#t~mem11.base| .cse298) (= 0 |c_main_#t~mem11.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse297 |c_#NULL.offset|) (= c_main_~list~5.offset 0) (= .cse296 .cse300) (= .cse301 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 1 .cse301) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= .cse300 .cse291) (= .cse302 8)))) (= .cse302 (select |c_old(#length)| v_weq0_1))))) (forall ((v_weq0_1 Int)) (or (let ((.cse308 (+ c_main_~list~5.offset 4))) (let ((.cse304 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse305 (select |c_old(#valid)| 0)) (.cse307 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse308)) (.cse306 (select |c_#valid| c_main_~list~5.offset)) (.cse303 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse308))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse303 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse304 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse304) (= c_main_~list~5.offset 0) (= .cse305 .cse306) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= .cse307 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse305) (= |c_#NULL.base| .cse307) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse306 .cse303)))) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))) (forall ((v_weq0_1 Int)) (let ((.cse327 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse322 (+ c_main_~list~5.offset 4))) (let ((.cse315 (select |c_#valid| c_main_~list~5.offset)) (.cse328 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse314 (select |c_old(#valid)| 0)) (.cse329 (select .cse327 .cse322))) (let ((.cse309 (= 0 |c_main_#t~mem11.offset|)) (.cse310 (= .cse329 |c_main_#t~mem10.offset|)) (.cse311 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse313 (not (= c_main_~list~5.base 0))) (.cse316 (not (= 0 c_main_~list~5.base))) (.cse317 (= |c_main_#t~mem11.base| |c_#NULL.base|)) (.cse319 (= |c_main_#t~mem10.base| .cse314)) (.cse312 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse320 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse323 (not (= v_weq0_1 0))) (.cse318 (select .cse328 .cse322)) (.cse321 (= .cse315 .cse329))) (or (and .cse309 .cse310 .cse311 (= .cse312 |c_#NULL.offset|) .cse313 (= v_weq0_1 .cse312) (= c_main_~list~5.offset 0) (= .cse314 .cse315) .cse316 .cse317 (= .cse318 c_main_~list~5.offset) .cse319 (= |c_#NULL.base| .cse318) .cse320 (= |c_main_#t~mem10.offset| v_weq0_1) .cse321) (and (not (= v_weq0_1 .cse322)) .cse323) (let ((.cse326 (select .cse328 v_weq0_1))) (let ((.cse324 (select |c_old(#valid)| .cse326)) (.cse325 (select .cse327 v_weq0_1))) (and (= .cse324 |c_#NULL.offset|) .cse309 .cse310 .cse311 .cse313 (= .cse314 .cse325) .cse316 (= .cse326 .cse324) (= .cse325 .cse315) (= .cse322 v_weq0_1) .cse317 .cse319 (= .cse312 .cse326) (= |c_main_#t~mem10.offset| .cse312) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse318 0) .cse320 .cse323 (= c_main_~list~5.offset .cse318) .cse321))) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (forall ((v_weq0_1 Int)) (let ((.cse347 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse339 (+ c_main_~list~5.offset 4))) (let ((.cse338 (select |c_#valid| c_main_~list~5.offset)) (.cse331 (select .cse347 .cse339)) (.cse342 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse348 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse334 (select |c_old(#valid)| 0))) (let ((.cse330 (= 0 |c_main_#t~mem11.offset|)) (.cse332 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse333 (not (= c_main_~list~5.base 0))) (.cse337 (not (= 0 c_main_~list~5.base))) (.cse340 (= |c_main_#t~mem11.base| |c_#NULL.base|)) (.cse341 (= |c_main_#t~mem10.base| .cse334)) (.cse344 (select .cse348 .cse339)) (.cse343 (= |c_main_#t~mem10.offset| .cse342)) (.cse345 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse346 (= .cse338 .cse331)) (.cse336 (select .cse348 v_weq0_1))) (or (let ((.cse335 (select .cse347 v_weq0_1))) (and .cse330 (= .cse331 |c_main_#t~mem10.offset|) .cse332 .cse333 (= .cse334 .cse335) (= .cse336 |c_#NULL.offset|) .cse337 (= .cse335 .cse338) (= .cse339 v_weq0_1) .cse340 .cse341 (= .cse342 .cse336) .cse343 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse344 0) .cse345 (= c_main_~list~5.offset .cse344) .cse346)) (and .cse330 .cse332 (= .cse342 |c_#NULL.offset|) .cse333 (= c_main_~list~5.offset 0) (= .cse334 .cse338) .cse337 .cse340 (= .cse344 c_main_~list~5.offset) .cse341 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse344) .cse343 .cse345 (= .cse331 v_weq0_1) .cse346) (= .cse336 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (forall ((v_weq0_1 Int)) (let ((.cse367 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse358 (+ c_main_~list~5.offset 4))) (let ((.cse357 (select |c_#valid| c_main_~list~5.offset)) (.cse365 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse354 (select |c_old(#valid)| 0)) (.cse366 (select .cse367 .cse358))) (let ((.cse349 (select .cse367 v_weq0_1)) (.cse350 (= 0 |c_main_#t~mem11.offset|)) (.cse351 (= .cse366 |c_main_#t~mem10.offset|)) (.cse352 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse353 (not (= c_main_~list~5.base 0))) (.cse361 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse356 (not (= 0 c_main_~list~5.base))) (.cse359 (= |c_main_#t~mem11.base| |c_#NULL.base|)) (.cse360 (= |c_main_#t~mem10.base| .cse354)) (.cse362 (select .cse365 .cse358)) (.cse363 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse364 (= .cse357 .cse366))) (or (= .cse349 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (let ((.cse355 (select .cse365 v_weq0_1))) (and .cse350 .cse351 .cse352 .cse353 (= .cse354 .cse349) (= .cse355 |c_#NULL.offset|) .cse356 (= .cse349 .cse357) (= .cse358 v_weq0_1) .cse359 .cse360 (= .cse361 .cse355) (= |c_main_#t~mem10.offset| .cse361) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse362 0) .cse363 (= c_main_~list~5.offset .cse362) .cse364)) (and .cse350 .cse351 .cse352 (= .cse361 |c_#NULL.offset|) .cse353 (= v_weq0_1 .cse361) (= c_main_~list~5.offset 0) (= .cse354 .cse357) .cse356 .cse359 (= .cse362 c_main_~list~5.offset) .cse360 (= |c_#NULL.base| .cse362) .cse363 (= |c_main_#t~mem10.offset| v_weq0_1) .cse364) (and (not (= v_weq0_1 .cse358)) (not (= v_weq0_1 0)))))))) (= .cse237 .cse368) (= .cse368 .cse236) (= 1 (select |c_#valid| |c_main_#t~malloc0.base|)) (not (= |c_#valid| |c_old(#valid)|))))) is different from false [2018-01-21 10:54:05,408 WARN L1007 $PredicateComparison]: unable to prove that (let ((.cse369 (+ c_main_~list~5.offset 4))) (let ((.cse199 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse369)) (.cse152 (select |c_old(#valid)| 0)) (.cse226 (select |c_#valid| c_main_~list~5.offset)) (.cse368 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse369)) (.cse225 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (forall ((v_weq0_1 Int)) (let ((.cse8 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse2 (select .cse8 v_weq0_1))) (or (let ((.cse5 (+ c_main_~list~5.offset 4)) (.cse9 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse1 (select |c_old(#valid)| 0)) (.cse3 (select .cse9 v_weq0_1)) (.cse6 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse7 (select .cse9 .cse5)) (.cse4 (select |c_#valid| c_main_~list~5.offset)) (.cse0 (select .cse8 .cse5))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse0 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse1 .cse2) (= .cse3 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse2 .cse4) (= .cse5 v_weq0_1) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= |c_main_#t~mem10.base| .cse1) (= .cse6 .cse3) (= |c_main_#t~mem10.offset| .cse6) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse7 0) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= c_main_~list~5.offset .cse7) (= .cse4 .cse0)))) (= .cse2 (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse36 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse37 (+ c_main_~list~5.offset 4))) (let ((.cse31 (select .cse36 .cse37)) (.cse39 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse42 (select |c_#valid| v_weq0_1)) (.cse41 (select |c_#valid| c_main_~list~5.offset)) (.cse20 (select |c_old(#valid)| v_weq0_1)) (.cse25 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse43 (select |c_old(#valid)| 0)) (.cse38 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse40 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse10 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse11 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse12 (= .cse38 .cse40)) (.cse13 (not (= 0 c_main_~list~5.base))) (.cse14 (= (select .cse40 .cse37) |c_main_#t~mem11.base|)) (.cse15 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse17 (= |c_main_#t~mem10.base| .cse43)) (.cse18 (= |c_main_#t~mem10.offset| .cse25)) (.cse19 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse21 (= .cse36 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse16 (select .cse38 .cse37)) (.cse22 (= |c_main_#t~mem11.base| .cse20)) (.cse23 (= 0 |c_main_#t~mem11.offset|)) (.cse24 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse26 (= .cse43 .cse41)) (.cse27 (= .cse42 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse28 (= .cse39 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse29 (= 1 .cse42)) (.cse30 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse32 (= .cse41 .cse31)) (.cse33 (= (select |c_#length| v_weq0_1) 8)) (.cse35 (select .cse40 v_weq1_1))) (or (and .cse10 .cse11 .cse12 .cse13 .cse14 .cse15 (= .cse16 c_main_~list~5.offset) .cse17 (= |c_#NULL.base| .cse16) .cse18 .cse19 (= .cse20 |c_#NULL.base|) .cse21 .cse22 .cse23 .cse24 (= .cse25 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse26 .cse27 .cse28 .cse29 .cse30 (= .cse31 v_weq1_1) .cse32 .cse33) (let ((.cse34 (select .cse38 v_weq1_1))) (and .cse10 .cse11 (= .cse31 |c_main_#t~mem10.offset|) .cse12 .cse13 .cse14 .cse15 .cse17 .cse18 .cse19 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse16 0) (= .cse25 .cse34) (= .cse20 .cse35) .cse21 (= c_main_~list~5.offset .cse16) (= .cse34 |c_#NULL.offset|) .cse22 .cse23 .cse24 .cse26 .cse27 .cse28 .cse29 (= |c_main_#t~malloc0.offset| (select .cse36 v_weq1_1)) (= .cse35 |c_#NULL.base|) (= .cse37 v_weq1_1) .cse30 .cse32 .cse33)) (= (select .cse39 v_weq1_1) .cse35)))))) (forall ((v_weq0_1 Int)) (let ((.cse61 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse53 (+ c_main_~list~5.offset 4))) (let ((.cse52 (select |c_#valid| c_main_~list~5.offset)) (.cse45 (select .cse61 .cse53)) (.cse56 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse62 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse48 (select |c_old(#valid)| 0))) (let ((.cse44 (= 0 |c_main_#t~mem11.offset|)) (.cse46 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse47 (not (= c_main_~list~5.base 0))) (.cse51 (not (= 0 c_main_~list~5.base))) (.cse54 (= |c_main_#t~mem11.base| |c_#NULL.base|)) (.cse55 (= |c_main_#t~mem10.base| .cse48)) (.cse58 (select .cse62 .cse53)) (.cse57 (= |c_main_#t~mem10.offset| .cse56)) (.cse59 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse60 (= .cse52 .cse45)) (.cse50 (select .cse62 v_weq0_1))) (or (let ((.cse49 (select .cse61 v_weq0_1))) (and .cse44 (= .cse45 |c_main_#t~mem10.offset|) .cse46 .cse47 (= .cse48 .cse49) (= .cse50 |c_#NULL.offset|) .cse51 (= .cse49 .cse52) (= .cse53 v_weq0_1) .cse54 .cse55 (= .cse56 .cse50) .cse57 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse58 0) .cse59 (= c_main_~list~5.offset .cse58) .cse60)) (and .cse44 .cse46 (= .cse56 |c_#NULL.offset|) .cse47 (= c_main_~list~5.offset 0) (= .cse48 .cse52) .cse51 .cse54 (= .cse58 c_main_~list~5.offset) .cse55 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse58) .cse57 .cse59 (= .cse45 v_weq0_1) .cse60) (and (not (= v_weq0_1 .cse53)) (not (= v_weq0_1 0))) (= .cse50 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse93 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse91 (+ c_main_~list~5.offset 4))) (let ((.cse85 (select .cse93 .cse91)) (.cse96 (select |c_#valid| v_weq0_1)) (.cse95 (select |c_#valid| c_main_~list~5.offset)) (.cse75 (select |c_old(#valid)| v_weq0_1)) (.cse63 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse79 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse97 (select |c_old(#valid)| 0)) (.cse94 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse92 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse64 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse65 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse66 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse64)) (.cse67 (= .cse94 .cse92)) (.cse68 (not (= 0 c_main_~list~5.base))) (.cse69 (= (select .cse92 .cse91) |c_main_#t~mem11.base|)) (.cse70 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse72 (= |c_main_#t~mem10.base| .cse97)) (.cse73 (= |c_main_#t~mem10.offset| .cse79)) (.cse74 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse76 (= .cse93 .cse63)) (.cse71 (select .cse94 .cse91)) (.cse77 (= |c_main_#t~mem11.base| .cse75)) (.cse78 (= 0 |c_main_#t~mem11.offset|)) (.cse80 (= .cse97 .cse95)) (.cse81 (= .cse96 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse82 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse83 (= 1 .cse96)) (.cse84 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse86 (= .cse95 .cse85)) (.cse87 (= (select |c_#length| v_weq0_1) 8))) (or (= (select .cse63 v_weq1_1) (select .cse64 v_weq1_1)) (and .cse65 .cse66 .cse67 .cse68 .cse69 .cse70 (= .cse71 c_main_~list~5.offset) .cse72 (= |c_#NULL.base| .cse71) .cse73 .cse74 (= .cse75 |c_#NULL.base|) .cse76 .cse77 .cse78 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse79 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse80 .cse81 .cse82 .cse83 .cse84 (= .cse85 v_weq1_1) .cse86 .cse87) (let ((.cse89 (select .cse94 v_weq1_1)) (.cse88 (select .cse93 v_weq1_1)) (.cse90 (select .cse92 v_weq1_1))) (and .cse65 .cse66 (= .cse85 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse88) .cse67 .cse68 .cse69 .cse70 .cse72 .cse73 .cse74 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse71 0) (= .cse79 .cse89) (= .cse75 .cse90) .cse76 (= c_main_~list~5.offset .cse71) (= .cse89 |c_#NULL.offset|) .cse77 .cse78 .cse80 .cse81 .cse82 .cse83 (= .cse88 |c_main_#t~malloc0.offset|) (= .cse90 |c_#NULL.base|) (= .cse91 v_weq1_1) .cse84 .cse86 .cse87))))))) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (forall ((v_weq0_1 Int)) (let ((.cse106 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse100 (select .cse106 v_weq0_1))) (or (let ((.cse103 (+ c_main_~list~5.offset 4)) (.cse107 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse99 (select |c_old(#valid)| 0)) (.cse101 (select .cse107 v_weq0_1)) (.cse104 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse105 (select .cse107 .cse103)) (.cse102 (select |c_#valid| c_main_~list~5.offset)) (.cse98 (select .cse106 .cse103))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse98 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse99 .cse100) (= .cse101 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse100 .cse102) (= .cse103 v_weq0_1) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= |c_main_#t~mem10.base| .cse99) (= .cse104 .cse101) (= |c_main_#t~mem10.offset| .cse104) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse105 0) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= c_main_~list~5.offset .cse105) (= .cse102 .cse98)))) (= .cse100 (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (or (not (= v_weq0_1 c_main_~list~5.base)) (and (not (= v_weq1_1 (+ c_main_~list~5.offset 4))) (not (= v_weq1_1 0))) (= (select (select |c_#memory_$Pointer$.base| v_weq0_1) v_weq1_1) (select (select |c_#memory_$Pointer$.offset| v_weq0_1) v_weq1_1)))) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~mem11.base| |c_#NULL.base|) (forall ((v_weq0_1 Int)) (let ((.cse117 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse111 (select .cse117 v_weq0_1))) (or (let ((.cse113 (+ c_main_~list~5.offset 4)) (.cse116 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse110 (select .cse116 v_weq0_1)) (.cse109 (select |c_old(#valid)| 0)) (.cse114 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse115 (select .cse117 .cse113)) (.cse112 (select |c_#valid| c_main_~list~5.offset)) (.cse108 (select .cse116 .cse113))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse108 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse109 .cse110) (= .cse111 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse110 .cse112) (= .cse113 v_weq0_1) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= |c_main_#t~mem10.base| .cse109) (= .cse114 .cse111) (= |c_main_#t~mem10.offset| .cse114) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse115 0) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= c_main_~list~5.offset .cse115) (= .cse112 .cse108)))) (not (= v_weq0_1 0)) (= .cse111 (select |c_old(#valid)| v_weq0_1)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse144 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse145 (+ c_main_~list~5.offset 4))) (let ((.cse139 (select .cse144 .cse145)) (.cse150 (select |c_#valid| v_weq0_1)) (.cse149 (select |c_#valid| c_main_~list~5.offset)) (.cse128 (select |c_old(#valid)| v_weq0_1)) (.cse133 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse151 (select |c_old(#valid)| 0)) (.cse146 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse148 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse147 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse118 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse119 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse147)) (.cse120 (= .cse146 .cse148)) (.cse121 (not (= 0 c_main_~list~5.base))) (.cse122 (= (select .cse148 .cse145) |c_main_#t~mem11.base|)) (.cse123 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse125 (= |c_main_#t~mem10.base| .cse151)) (.cse126 (= |c_main_#t~mem10.offset| .cse133)) (.cse127 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse129 (= .cse144 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse124 (select .cse146 .cse145)) (.cse130 (= |c_main_#t~mem11.base| .cse128)) (.cse131 (= 0 |c_main_#t~mem11.offset|)) (.cse132 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse134 (= .cse151 .cse149)) (.cse135 (= .cse150 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse136 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse137 (= 1 .cse150)) (.cse138 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse140 (= .cse149 .cse139)) (.cse141 (= (select |c_#length| v_weq0_1) 8)) (.cse143 (select .cse148 v_weq1_1))) (or (and .cse118 .cse119 .cse120 .cse121 .cse122 .cse123 (= .cse124 c_main_~list~5.offset) .cse125 (= |c_#NULL.base| .cse124) .cse126 .cse127 (= .cse128 |c_#NULL.base|) .cse129 .cse130 .cse131 .cse132 (= .cse133 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse134 .cse135 .cse136 .cse137 .cse138 (= .cse139 v_weq1_1) .cse140 .cse141) (let ((.cse142 (select .cse146 v_weq1_1))) (and .cse118 .cse119 (= .cse139 |c_main_#t~mem10.offset|) .cse120 .cse121 .cse122 .cse123 .cse125 .cse126 .cse127 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse124 0) (= .cse133 .cse142) (= .cse128 .cse143) .cse129 (= c_main_~list~5.offset .cse124) (= .cse142 |c_#NULL.offset|) .cse130 .cse131 .cse132 .cse134 .cse135 .cse136 .cse137 (= |c_main_#t~malloc0.offset| (select .cse144 v_weq1_1)) (= .cse143 |c_#NULL.base|) (= .cse145 v_weq1_1) .cse138 .cse140 .cse141)) (= .cse143 (select .cse147 v_weq1_1)) (not (= v_weq0_1 c_main_~list~5.base)) (and (not (= v_weq1_1 .cse145)) (not (= v_weq1_1 0)))))))) (= |c_main_#t~mem10.base| .cse152) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse184 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse153 (+ c_main_~list~5.offset 4))) (let ((.cse158 (select .cse184 .cse153)) (.cse154 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse187 (select |c_#valid| v_weq0_1)) (.cse186 (select |c_#valid| c_main_~list~5.offset)) (.cse171 (select |c_old(#valid)| v_weq0_1)) (.cse155 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse169 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse188 (select |c_old(#valid)| 0)) (.cse185 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse183 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse156 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse157 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse160 (not (= c_main_~list~5.base 0))) (.cse161 (= .cse185 .cse183)) (.cse162 (not (= 0 c_main_~list~5.base))) (.cse163 (= (select .cse183 .cse153) |c_main_#t~mem11.base|)) (.cse164 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse165 (= |c_main_#t~mem10.base| .cse188)) (.cse168 (select .cse185 .cse153)) (.cse166 (= |c_main_#t~mem10.offset| .cse169)) (.cse167 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse173 (= .cse184 .cse155)) (.cse174 (= |c_main_#t~mem11.base| .cse171)) (.cse175 (= 0 |c_main_#t~mem11.offset|)) (.cse176 (= .cse188 .cse186)) (.cse177 (= .cse187 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse178 (= .cse154 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse179 (= 1 .cse187)) (.cse180 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse181 (= .cse186 .cse158)) (.cse182 (= (select |c_#length| v_weq0_1) 8))) (or (not (= v_weq0_1 c_main_~list~5.base)) (and (not (= v_weq1_1 .cse153)) (not (= v_weq1_1 0))) (= (select .cse154 v_weq1_1) (select .cse155 v_weq1_1)) (let ((.cse170 (select .cse185 v_weq1_1)) (.cse159 (select .cse184 v_weq1_1)) (.cse172 (select .cse183 v_weq1_1))) (and .cse156 .cse157 (= .cse158 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse159) .cse160 .cse161 .cse162 .cse163 .cse164 .cse165 .cse166 .cse167 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse168 0) (= .cse169 .cse170) (= .cse171 .cse172) .cse173 (= c_main_~list~5.offset .cse168) (= .cse170 |c_#NULL.offset|) .cse174 .cse175 .cse176 .cse177 .cse178 .cse179 (= .cse159 |c_main_#t~malloc0.offset|) (= .cse172 |c_#NULL.base|) (= .cse153 v_weq1_1) .cse180 .cse181 .cse182)) (and .cse156 .cse157 .cse160 .cse161 .cse162 .cse163 .cse164 (= .cse168 c_main_~list~5.offset) .cse165 (= |c_#NULL.base| .cse168) .cse166 .cse167 (= .cse171 |c_#NULL.base|) .cse173 .cse174 .cse175 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse169 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse176 .cse177 .cse178 .cse179 .cse180 (= .cse158 v_weq1_1) .cse181 .cse182)))))) (not (= |c_#valid| |c_#length|)) (forall ((v_weq0_1 Int)) (let ((.cse198 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse192 (select .cse198 v_weq0_1))) (or (let ((.cse194 (+ c_main_~list~5.offset 4)) (.cse197 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse191 (select .cse197 v_weq0_1)) (.cse190 (select |c_old(#valid)| 0)) (.cse195 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse196 (select .cse198 .cse194)) (.cse193 (select |c_#valid| c_main_~list~5.offset)) (.cse189 (select .cse197 .cse194))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse189 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse190 .cse191) (= .cse192 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse191 .cse193) (= .cse194 v_weq0_1) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= |c_main_#t~mem10.base| .cse190) (= .cse195 .cse192) (= |c_main_#t~mem10.offset| .cse195) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse196 0) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= c_main_~list~5.offset .cse196) (= .cse193 .cse189)))) (= .cse192 (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))))) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse199 0) (= c_main_~list~5.offset .cse199) (not (= |c_#length| |c_old(#valid)|)) (forall ((v_weq0_1 Int)) (or (let ((.cse205 (+ c_main_~list~5.offset 4))) (let ((.cse201 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse202 (select |c_old(#valid)| 0)) (.cse204 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse205)) (.cse203 (select |c_#valid| c_main_~list~5.offset)) (.cse200 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse205))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse200 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse201 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse201) (= c_main_~list~5.offset 0) (= .cse202 .cse203) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= .cse204 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse202) (= |c_#NULL.base| .cse204) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse203 .cse200)))) (= (select |c_old(#valid)| v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)))) (= 0 |c_main_#t~mem11.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (forall ((v_weq0_1 Int)) (let ((.cse224 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse215 (+ c_main_~list~5.offset 4))) (let ((.cse214 (select |c_#valid| c_main_~list~5.offset)) (.cse207 (select .cse224 .cse215)) (.cse218 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse223 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse210 (select |c_old(#valid)| 0))) (let ((.cse206 (= 0 |c_main_#t~mem11.offset|)) (.cse208 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse209 (not (= c_main_~list~5.base 0))) (.cse213 (not (= 0 c_main_~list~5.base))) (.cse216 (= |c_main_#t~mem11.base| |c_#NULL.base|)) (.cse217 (= |c_main_#t~mem10.base| .cse210)) (.cse220 (select .cse223 .cse215)) (.cse219 (= |c_main_#t~mem10.offset| .cse218)) (.cse221 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse222 (= .cse214 .cse207)) (.cse211 (select .cse224 v_weq0_1))) (or (let ((.cse212 (select .cse223 v_weq0_1))) (and .cse206 (= .cse207 |c_main_#t~mem10.offset|) .cse208 .cse209 (= .cse210 .cse211) (= .cse212 |c_#NULL.offset|) .cse213 (= .cse211 .cse214) (= .cse215 v_weq0_1) .cse216 .cse217 (= .cse218 .cse212) .cse219 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse220 0) .cse221 (= c_main_~list~5.offset .cse220) .cse222)) (and .cse206 .cse208 (= .cse218 |c_#NULL.offset|) .cse209 (= c_main_~list~5.offset 0) (= .cse210 .cse214) .cse213 .cse216 (= .cse220 c_main_~list~5.offset) .cse217 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse220) .cse219 .cse221 (= .cse207 v_weq0_1) .cse222) (= .cse211 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1))))))) (= .cse225 |c_main_#t~mem10.offset|) (= .cse152 .cse226) (forall ((v_weq0_1 Int)) (or (let ((.cse232 (+ c_main_~list~5.offset 4))) (let ((.cse228 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse229 (select |c_old(#valid)| 0)) (.cse231 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse232)) (.cse230 (select |c_#valid| c_main_~list~5.offset)) (.cse227 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse232))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse227 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse228 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse228) (= c_main_~list~5.offset 0) (= .cse229 .cse230) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= .cse231 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse229) (= |c_#NULL.base| .cse231) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse230 .cse227)))) (= (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))) (= |c_main_#t~mem10.offset| |c_#NULL.offset|) (forall ((v_weq0_1 Int)) (or (let ((.cse238 (+ c_main_~list~5.offset 4))) (let ((.cse234 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse235 (select |c_old(#valid)| 0)) (.cse237 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse238)) (.cse236 (select |c_#valid| c_main_~list~5.offset)) (.cse233 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse238))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse233 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse234 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse234) (= c_main_~list~5.offset 0) (= .cse235 .cse236) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= .cse237 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse235) (= |c_#NULL.base| .cse237) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse236 .cse233)))) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)))) (forall ((v_weq0_1 Int)) (let ((.cse239 (select |c_old(#valid)| v_weq0_1)) (.cse240 (select |c_#valid| v_weq0_1))) (or (= .cse239 .cse240) (let ((.cse248 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse242 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse244 (+ c_main_~list~5.offset 4))) (let ((.cse243 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse245 (select .cse242 .cse244)) (.cse247 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse246 (select |c_old(#valid)| 0)) (.cse249 (select |c_#valid| c_main_~list~5.offset)) (.cse241 (select .cse248 .cse244))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse241 |c_main_#t~mem10.offset|) (not (= c_main_~list~5.base 0)) (= .cse242 .cse243) (= (select .cse243 .cse244) |c_main_#t~mem11.base|) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= .cse245 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse246) (= |c_#NULL.base| .cse245) (= |c_main_#t~mem10.offset| .cse247) (= v_weq0_1 |c_main_#t~malloc0.base|) (= .cse239 |c_#NULL.base|) (= .cse248 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= |c_main_#t~mem11.base| .cse239) (= 0 |c_main_#t~mem11.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse247 |c_#NULL.offset|) (= c_main_~list~5.offset 0) (= .cse246 .cse249) (= .cse240 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 1 .cse240) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= .cse249 .cse241) (= (select |c_#length| v_weq0_1) 8))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse283 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse277 (+ c_main_~list~5.offset 4))) (let ((.cse252 (select .cse283 .cse277)) (.cse286 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse289 (select |c_#valid| v_weq0_1)) (.cse288 (select |c_#valid| c_main_~list~5.offset)) (.cse265 (select |c_old(#valid)| v_weq0_1)) (.cse282 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse263 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse290 (select |c_old(#valid)| 0)) (.cse285 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse284 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse287 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse278 (not (= v_weq1_1 0))) (.cse250 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse251 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse287)) (.cse254 (not (= c_main_~list~5.base 0))) (.cse255 (= .cse285 .cse284)) (.cse257 (not (= 0 c_main_~list~5.base))) (.cse272 (select .cse284 .cse277)) (.cse258 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse259 (= |c_main_#t~mem10.base| .cse290)) (.cse262 (select .cse285 .cse277)) (.cse260 (= |c_main_#t~mem10.offset| .cse263)) (.cse261 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse267 (= .cse283 .cse282)) (.cse269 (= |c_main_#t~mem11.base| .cse265)) (.cse270 (= 0 |c_main_#t~mem11.offset|)) (.cse273 (= .cse290 .cse288)) (.cse274 (= .cse289 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse275 (= .cse286 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse276 (= 1 .cse289)) (.cse279 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse280 (= .cse288 .cse252)) (.cse281 (= (select |c_#length| v_weq0_1) 8))) (or (not (= v_weq0_1 c_main_~list~5.base)) (let ((.cse264 (select .cse285 v_weq1_1)) (.cse266 (select .cse284 v_weq1_1))) (let ((.cse271 (select |c_old(#valid)| .cse266)) (.cse256 (select |c_old(#valid)| .cse264)) (.cse253 (select .cse283 v_weq1_1)) (.cse268 (select .cse282 .cse277))) (and .cse250 .cse251 (= .cse252 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| .cse253) .cse254 .cse255 (= |c_#NULL.base| .cse256) .cse257 .cse258 .cse259 .cse260 .cse261 (= .cse262 0) (= .cse263 .cse264) (= .cse265 .cse266) .cse267 (= c_main_~list~5.offset .cse262) (= .cse264 |c_#NULL.offset|) (= .cse268 |c_#NULL.base|) .cse269 .cse270 (= .cse271 |c_main_#t~mem11.base|) (= .cse272 .cse271) .cse273 .cse274 (= .cse256 c_main_~list~5.offset) .cse275 .cse276 (= .cse253 |c_main_#t~malloc0.offset|) (= .cse277 v_weq1_1) .cse278 .cse279 .cse280 (= .cse266 .cse268) .cse281))) (= (select .cse286 v_weq1_1) (select .cse287 v_weq1_1)) (and (not (= v_weq1_1 .cse277)) .cse278) (and .cse250 .cse251 .cse254 .cse255 .cse257 (= .cse272 |c_main_#t~mem11.base|) .cse258 (= .cse262 c_main_~list~5.offset) .cse259 (= |c_#NULL.base| .cse262) .cse260 .cse261 (= .cse265 |c_#NULL.base|) .cse267 .cse269 .cse270 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse263 |c_#NULL.offset|) (= v_weq1_1 |c_main_#t~mem10.offset|) (= c_main_~list~5.offset 0) .cse273 .cse274 .cse275 .cse276 .cse279 (= .cse252 v_weq1_1) .cse280 .cse281)))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 (+ c_main_~list~5.offset 4))) (not (= v_weq0_1 0))))) (forall ((v_weq0_1 Int)) (let ((.cse302 (select |c_#length| v_weq0_1))) (or (let ((.cse299 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse292 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse294 (+ c_main_~list~5.offset 4))) (let ((.cse293 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse295 (select .cse292 .cse294)) (.cse298 (select |c_old(#valid)| v_weq0_1)) (.cse297 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse296 (select |c_old(#valid)| 0)) (.cse301 (select |c_#valid| v_weq0_1)) (.cse300 (select |c_#valid| c_main_~list~5.offset)) (.cse291 (select .cse299 .cse294))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse291 |c_main_#t~mem10.offset|) (= v_weq0_1 c_main_~list~5.base) (= .cse292 .cse293) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (= (select .cse293 .cse294) |c_main_#t~mem11.base|) (= .cse295 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse296) (= |c_#NULL.base| .cse295) (not (= 0 |c_main_#t~malloc0.base|)) (= |c_main_#t~mem10.offset| .cse297) (= .cse298 |c_#NULL.base|) (= .cse299 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= |c_main_#t~mem11.base| .cse298) (= 0 |c_main_#t~mem11.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse297 |c_#NULL.offset|) (= c_main_~list~5.offset 0) (= .cse296 .cse300) (= .cse301 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 1 .cse301) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= .cse300 .cse291) (= .cse302 8)))) (= .cse302 (select |c_old(#length)| v_weq0_1))))) (forall ((v_weq0_1 Int)) (or (let ((.cse308 (+ c_main_~list~5.offset 4))) (let ((.cse304 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse305 (select |c_old(#valid)| 0)) (.cse307 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse308)) (.cse306 (select |c_#valid| c_main_~list~5.offset)) (.cse303 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse308))) (and (= 0 |c_main_#t~mem11.offset|) (= .cse303 |c_main_#t~mem10.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse304 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= v_weq0_1 .cse304) (= c_main_~list~5.offset 0) (= .cse305 .cse306) (not (= 0 c_main_~list~5.base)) (= |c_main_#t~mem11.base| |c_#NULL.base|) (= .cse307 c_main_~list~5.offset) (= |c_main_#t~mem10.base| .cse305) (= |c_#NULL.base| .cse307) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (= |c_main_#t~mem10.offset| v_weq0_1) (= .cse306 .cse303)))) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))) (forall ((v_weq0_1 Int)) (let ((.cse327 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse322 (+ c_main_~list~5.offset 4))) (let ((.cse315 (select |c_#valid| c_main_~list~5.offset)) (.cse328 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse314 (select |c_old(#valid)| 0)) (.cse329 (select .cse327 .cse322))) (let ((.cse309 (= 0 |c_main_#t~mem11.offset|)) (.cse310 (= .cse329 |c_main_#t~mem10.offset|)) (.cse311 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse313 (not (= c_main_~list~5.base 0))) (.cse316 (not (= 0 c_main_~list~5.base))) (.cse317 (= |c_main_#t~mem11.base| |c_#NULL.base|)) (.cse319 (= |c_main_#t~mem10.base| .cse314)) (.cse312 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse320 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse323 (not (= v_weq0_1 0))) (.cse318 (select .cse328 .cse322)) (.cse321 (= .cse315 .cse329))) (or (and .cse309 .cse310 .cse311 (= .cse312 |c_#NULL.offset|) .cse313 (= v_weq0_1 .cse312) (= c_main_~list~5.offset 0) (= .cse314 .cse315) .cse316 .cse317 (= .cse318 c_main_~list~5.offset) .cse319 (= |c_#NULL.base| .cse318) .cse320 (= |c_main_#t~mem10.offset| v_weq0_1) .cse321) (and (not (= v_weq0_1 .cse322)) .cse323) (let ((.cse326 (select .cse328 v_weq0_1))) (let ((.cse324 (select |c_old(#valid)| .cse326)) (.cse325 (select .cse327 v_weq0_1))) (and (= .cse324 |c_#NULL.offset|) .cse309 .cse310 .cse311 .cse313 (= .cse314 .cse325) .cse316 (= .cse326 .cse324) (= .cse325 .cse315) (= .cse322 v_weq0_1) .cse317 .cse319 (= .cse312 .cse326) (= |c_main_#t~mem10.offset| .cse312) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse318 0) .cse320 .cse323 (= c_main_~list~5.offset .cse318) .cse321))) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (forall ((v_weq0_1 Int)) (let ((.cse347 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse339 (+ c_main_~list~5.offset 4))) (let ((.cse338 (select |c_#valid| c_main_~list~5.offset)) (.cse331 (select .cse347 .cse339)) (.cse342 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse348 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse334 (select |c_old(#valid)| 0))) (let ((.cse330 (= 0 |c_main_#t~mem11.offset|)) (.cse332 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse333 (not (= c_main_~list~5.base 0))) (.cse337 (not (= 0 c_main_~list~5.base))) (.cse340 (= |c_main_#t~mem11.base| |c_#NULL.base|)) (.cse341 (= |c_main_#t~mem10.base| .cse334)) (.cse344 (select .cse348 .cse339)) (.cse343 (= |c_main_#t~mem10.offset| .cse342)) (.cse345 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse346 (= .cse338 .cse331)) (.cse336 (select .cse348 v_weq0_1))) (or (let ((.cse335 (select .cse347 v_weq0_1))) (and .cse330 (= .cse331 |c_main_#t~mem10.offset|) .cse332 .cse333 (= .cse334 .cse335) (= .cse336 |c_#NULL.offset|) .cse337 (= .cse335 .cse338) (= .cse339 v_weq0_1) .cse340 .cse341 (= .cse342 .cse336) .cse343 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse344 0) .cse345 (= c_main_~list~5.offset .cse344) .cse346)) (and .cse330 .cse332 (= .cse342 |c_#NULL.offset|) .cse333 (= c_main_~list~5.offset 0) (= .cse334 .cse338) .cse337 .cse340 (= .cse344 c_main_~list~5.offset) .cse341 (= v_weq0_1 |c_main_#t~mem10.offset|) (= |c_#NULL.base| .cse344) .cse343 .cse345 (= .cse331 v_weq0_1) .cse346) (= .cse336 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|) (forall ((v_weq0_1 Int)) (let ((.cse367 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse358 (+ c_main_~list~5.offset 4))) (let ((.cse357 (select |c_#valid| c_main_~list~5.offset)) (.cse365 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse354 (select |c_old(#valid)| 0)) (.cse366 (select .cse367 .cse358))) (let ((.cse349 (select .cse367 v_weq0_1)) (.cse350 (= 0 |c_main_#t~mem11.offset|)) (.cse351 (= .cse366 |c_main_#t~mem10.offset|)) (.cse352 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse353 (not (= c_main_~list~5.base 0))) (.cse361 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse356 (not (= 0 c_main_~list~5.base))) (.cse359 (= |c_main_#t~mem11.base| |c_#NULL.base|)) (.cse360 (= |c_main_#t~mem10.base| .cse354)) (.cse362 (select .cse365 .cse358)) (.cse363 (= |c_main_#t~mem11.offset| |c_main_#t~mem10.base|)) (.cse364 (= .cse357 .cse366))) (or (= .cse349 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (let ((.cse355 (select .cse365 v_weq0_1))) (and .cse350 .cse351 .cse352 .cse353 (= .cse354 .cse349) (= .cse355 |c_#NULL.offset|) .cse356 (= .cse349 .cse357) (= .cse358 v_weq0_1) .cse359 .cse360 (= .cse361 .cse355) (= |c_main_#t~mem10.offset| .cse361) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse362 0) .cse363 (= c_main_~list~5.offset .cse362) .cse364)) (and .cse350 .cse351 .cse352 (= .cse361 |c_#NULL.offset|) .cse353 (= v_weq0_1 .cse361) (= c_main_~list~5.offset 0) (= .cse354 .cse357) .cse356 .cse359 (= .cse362 c_main_~list~5.offset) .cse360 (= |c_#NULL.base| .cse362) .cse363 (= |c_main_#t~mem10.offset| v_weq0_1) .cse364) (and (not (= v_weq0_1 .cse358)) (not (= v_weq0_1 0)))))))) (= .cse226 .cse368) |c_main_#t~short12| (= .cse368 .cse225) (= 1 (select |c_#valid| |c_main_#t~malloc0.base|)) (not (= |c_#valid| |c_old(#valid)|))))) is different from false [2018-01-21 10:54:06,205 WARN L1007 $PredicateComparison]: unable to prove that (let ((.cse324 (+ c_main_~list~5.offset 4))) (let ((.cse300 (select |c_old(#valid)| 0)) (.cse199 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse324)) (.cse301 (select |c_#valid| c_main_~list~5.offset)) (.cse323 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse324)) (.cse302 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (or (not (= v_weq0_1 c_main_~list~5.base)) (and (not (= v_weq1_1 (+ c_main_~list~5.offset 4))) (not (= v_weq1_1 0))) (= (select (select |c_#memory_$Pointer$.base| v_weq0_1) v_weq1_1) (select (select |c_#memory_$Pointer$.offset| v_weq0_1) v_weq1_1)))) (not (= 0 c_main_~list~5.base)) (forall ((v_weq0_1 Int)) (let ((.cse1 (select |c_#valid| v_weq0_1)) (.cse0 (select |c_old(#valid)| v_weq0_1))) (or (= .cse0 .cse1) (let ((.cse9 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse3 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse7 (+ c_main_~list~5.offset 4))) (let ((.cse5 (select |c_old(#valid)| 0)) (.cse4 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse8 (select .cse3 .cse7)) (.cse6 (select |c_#valid| c_main_~list~5.offset)) (.cse10 (select .cse9 .cse7)) (.cse2 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse2 |c_#NULL.offset|) (not (= c_main_~list~5.base 0)) (= .cse3 .cse4) (= .cse5 .cse6) (= .cse1 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 0 .cse5) (= 1 .cse1) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= (select .cse4 .cse7) .cse0) (= v_weq0_1 |c_main_#t~malloc0.base|) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse8 0) (= .cse0 |c_#NULL.base|) (= .cse9 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= c_main_~list~5.offset .cse8) (= .cse6 .cse10) (= (select |c_#length| v_weq0_1) 8) (= .cse10 .cse2))))))) (forall ((v_weq0_1 Int)) (let ((.cse19 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse11 (select .cse19 v_weq0_1))) (or (= .cse11 (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse15 (+ c_main_~list~5.offset 4)) (.cse20 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse12 (select |c_old(#valid)| 0)) (.cse13 (select .cse20 v_weq0_1)) (.cse17 (select .cse20 .cse15)) (.cse14 (select |c_#valid| c_main_~list~5.offset)) (.cse18 (select .cse19 .cse15)) (.cse16 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse12 .cse11) (= .cse13 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse11 .cse14) (= .cse15 v_weq0_1) (= 0 .cse12) (= .cse16 .cse13) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse17 0) (= c_main_~list~5.offset .cse17) (= .cse14 .cse18) (= .cse18 .cse16)))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse46 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse44 (+ c_main_~list~5.offset 4))) (let ((.cse38 (select .cse46 .cse44)) (.cse36 (select |c_old(#valid)| v_weq0_1)) (.cse48 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse51 (select |c_#valid| v_weq0_1)) (.cse52 (select |c_old(#valid)| 0)) (.cse50 (select |c_#valid| c_main_~list~5.offset)) (.cse49 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse47 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse45 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse21 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse22 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse24 (not (= c_main_~list~5.base 0))) (.cse25 (= .cse47 .cse45)) (.cse27 (not (= 0 c_main_~list~5.base))) (.cse32 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse35 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse37 (= .cse46 .cse49)) (.cse34 (select .cse47 .cse44)) (.cse26 (= .cse52 .cse50)) (.cse28 (= .cse51 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse29 (= .cse48 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse30 (= 0 .cse52)) (.cse31 (= 1 .cse51)) (.cse33 (= (select .cse45 .cse44) .cse36)) (.cse39 (= .cse50 .cse38)) (.cse40 (= (select |c_#length| v_weq0_1) 8)) (.cse23 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (or (and .cse21 .cse22 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse23 |c_#NULL.offset|) .cse24 .cse25 (= c_main_~list~5.offset 0) .cse26 .cse27 .cse28 .cse29 .cse30 .cse31 .cse32 .cse33 (= .cse34 c_main_~list~5.offset) (= |c_#NULL.base| .cse34) .cse35 (= v_weq1_1 .cse23) (= .cse36 |c_#NULL.base|) .cse37 (= .cse38 v_weq1_1) .cse39 .cse40) (not (= v_weq0_1 c_main_~list~5.base)) (let ((.cse42 (select .cse47 v_weq1_1)) (.cse41 (select .cse46 v_weq1_1)) (.cse43 (select .cse45 v_weq1_1))) (and .cse21 .cse22 (= |c_#NULL.offset| .cse41) .cse24 .cse25 .cse27 .cse32 .cse35 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse34 0) (= .cse23 .cse42) (= .cse36 .cse43) .cse37 (= c_main_~list~5.offset .cse34) (= .cse42 |c_#NULL.offset|) .cse26 .cse28 .cse29 .cse30 .cse31 .cse33 (= .cse41 |c_main_#t~malloc0.offset|) (= .cse43 |c_#NULL.base|) (= .cse44 v_weq1_1) .cse39 .cse40 (= .cse38 .cse23))) (and (not (= v_weq1_1 .cse44)) (not (= v_weq1_1 0))) (= (select .cse48 v_weq1_1) (select .cse49 v_weq1_1))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)) (let ((.cse58 (+ c_main_~list~5.offset 4))) (let ((.cse54 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse53 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse58)) (.cse56 (select |c_#valid| c_main_~list~5.offset)) (.cse57 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse58)) (.cse55 (select |c_old(#valid)| 0))) (and (= .cse53 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse54 |c_#NULL.base|) (not (= c_main_~list~5.base 0)) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse54) (= .cse55 .cse56) (not (= 0 c_main_~list~5.base)) (= |c_#NULL.offset| .cse53) (= .cse57 v_weq0_1) (= .cse56 .cse57) (= 0 .cse55)))) (not (= v_weq0_1 0)))) (= |c_#NULL.base| |c_#NULL.offset|) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse88 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse85 (+ c_main_~list~5.offset 4))) (let ((.cse76 (select .cse88 .cse85)) (.cse91 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse94 (select |c_#valid| v_weq0_1)) (.cse95 (select |c_old(#valid)| 0)) (.cse93 (select |c_#valid| c_main_~list~5.offset)) (.cse87 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse90 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse89 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse92 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse59 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse60 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse92)) (.cse62 (not (= c_main_~list~5.base 0))) (.cse63 (= .cse90 .cse89)) (.cse65 (not (= 0 c_main_~list~5.base))) (.cse70 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse74 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse75 (= .cse88 .cse87)) (.cse73 (select .cse90 .cse85)) (.cse71 (select .cse89 .cse85)) (.cse64 (= .cse95 .cse93)) (.cse72 (select |c_old(#valid)| v_weq0_1)) (.cse66 (= .cse94 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse67 (= .cse91 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse68 (= 0 .cse95)) (.cse69 (= 1 .cse94)) (.cse77 (= .cse93 .cse76)) (.cse78 (= (select |c_#length| v_weq0_1) 8)) (.cse61 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse86 (not (= v_weq1_1 0)))) (or (and .cse59 .cse60 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse61 |c_#NULL.offset|) .cse62 .cse63 (= c_main_~list~5.offset 0) .cse64 .cse65 .cse66 .cse67 .cse68 .cse69 .cse70 (= .cse71 .cse72) (= .cse73 c_main_~list~5.offset) (= |c_#NULL.base| .cse73) .cse74 (= v_weq1_1 .cse61) (= .cse72 |c_#NULL.base|) .cse75 (= .cse76 v_weq1_1) .cse77 .cse78) (not (= v_weq0_1 c_main_~list~5.base)) (let ((.cse81 (select .cse90 v_weq1_1)) (.cse82 (select .cse89 v_weq1_1))) (let ((.cse84 (select |c_old(#valid)| .cse82)) (.cse80 (select |c_old(#valid)| .cse81)) (.cse79 (select .cse88 v_weq1_1)) (.cse83 (select .cse87 .cse85))) (and .cse59 .cse60 (= |c_#NULL.offset| .cse79) .cse62 .cse63 (= |c_#NULL.base| .cse80) .cse65 .cse70 .cse74 (= .cse73 0) (= .cse61 .cse81) (= .cse72 .cse82) .cse75 (= c_main_~list~5.offset .cse73) (= .cse81 |c_#NULL.offset|) (= .cse83 |c_#NULL.base|) (= .cse71 .cse84) .cse64 (= .cse84 .cse72) .cse66 (= .cse80 c_main_~list~5.offset) .cse67 .cse68 .cse69 (= .cse79 |c_main_#t~malloc0.offset|) (= .cse85 v_weq1_1) .cse86 .cse77 (= .cse82 .cse83) .cse78 (= .cse76 .cse61)))) (= (select .cse91 v_weq1_1) (select .cse92 v_weq1_1)) (and (not (= v_weq1_1 .cse85)) .cse86)))))) (forall ((v_weq0_1 Int)) (let ((.cse108 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse107 (+ c_main_~list~5.offset 4))) (let ((.cse100 (select |c_#valid| c_main_~list~5.offset)) (.cse102 (select .cse108 .cse107)) (.cse109 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse99 (select |c_old(#valid)| 0))) (let ((.cse98 (not (= c_main_~list~5.base 0))) (.cse101 (not (= 0 c_main_~list~5.base))) (.cse104 (= 0 .cse99)) (.cse96 (select .cse109 .cse107)) (.cse103 (= .cse100 .cse102)) (.cse97 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse106 (select .cse109 v_weq0_1))) (or (and (= .cse96 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse97 |c_#NULL.base|) .cse98 (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse97) (= .cse99 .cse100) .cse101 (= |c_#NULL.offset| .cse96) (= .cse102 v_weq0_1) .cse103 .cse104) (let ((.cse105 (select .cse108 v_weq0_1))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse98 (= .cse99 .cse105) (= .cse106 |c_#NULL.offset|) .cse101 (= .cse105 .cse100) (= .cse107 v_weq0_1) .cse104 (= .cse97 .cse106) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse96 0) (= c_main_~list~5.offset .cse96) .cse103 (= .cse102 .cse97))) (= .cse106 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (let ((.cse115 (+ c_main_~list~5.offset 4))) (let ((.cse111 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse110 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse115)) (.cse113 (select |c_#valid| c_main_~list~5.offset)) (.cse114 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse115)) (.cse112 (select |c_old(#valid)| 0))) (and (= .cse110 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse111 |c_#NULL.base|) (not (= c_main_~list~5.base 0)) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse111) (= .cse112 .cse113) (not (= 0 c_main_~list~5.base)) (= |c_#NULL.offset| .cse110) (= .cse114 v_weq0_1) (= .cse113 .cse114) (= 0 .cse112)))) (not (= v_weq0_1 0)))) (forall ((v_weq0_1 Int)) (let ((.cse116 (select |c_#length| v_weq0_1))) (or (= .cse116 (select |c_old(#length)| v_weq0_1)) (let ((.cse126 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse118 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse123 (+ c_main_~list~5.offset 4))) (let ((.cse120 (select |c_old(#valid)| 0)) (.cse122 (select |c_#valid| v_weq0_1)) (.cse119 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse125 (select .cse118 .cse123)) (.cse124 (select |c_old(#valid)| v_weq0_1)) (.cse121 (select |c_#valid| c_main_~list~5.offset)) (.cse127 (select .cse126 .cse123)) (.cse117 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= v_weq0_1 c_main_~list~5.base) (= .cse117 |c_#NULL.offset|) (= .cse118 .cse119) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (= c_main_~list~5.offset 0) (= .cse120 .cse121) (= .cse122 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 0 .cse120) (= 1 .cse122) (= (select .cse119 .cse123) .cse124) (= .cse125 c_main_~list~5.offset) (= |c_#NULL.base| .cse125) (not (= 0 |c_main_#t~malloc0.base|)) (= .cse124 |c_#NULL.base|) (= .cse126 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= .cse121 .cse127) (= .cse116 8) (= .cse127 .cse117))))))) (forall ((v_weq0_1 Int)) (let ((.cse136 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse128 (select .cse136 v_weq0_1))) (or (= .cse128 (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse132 (+ c_main_~list~5.offset 4)) (.cse137 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse129 (select |c_old(#valid)| 0)) (.cse130 (select .cse137 v_weq0_1)) (.cse134 (select .cse137 .cse132)) (.cse131 (select |c_#valid| c_main_~list~5.offset)) (.cse135 (select .cse136 .cse132)) (.cse133 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse129 .cse128) (= .cse130 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse128 .cse131) (= .cse132 v_weq0_1) (= 0 .cse129) (= .cse133 .cse130) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse134 0) (= c_main_~list~5.offset .cse134) (= .cse131 .cse135) (= .cse135 .cse133)))))))) (forall ((v_weq0_1 Int)) (let ((.cse152 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse138 (+ c_main_~list~5.offset 4))) (let ((.cse144 (select |c_#valid| c_main_~list~5.offset)) (.cse146 (select .cse152 .cse138)) (.cse153 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse143 (select |c_old(#valid)| 0))) (let ((.cse142 (not (= c_main_~list~5.base 0))) (.cse145 (not (= 0 c_main_~list~5.base))) (.cse148 (= 0 .cse143)) (.cse139 (not (= v_weq0_1 0))) (.cse140 (select .cse153 .cse138)) (.cse147 (= .cse144 .cse146)) (.cse141 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (or (and (not (= v_weq0_1 .cse138)) .cse139) (and (= .cse140 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse141 |c_#NULL.base|) .cse142 (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse141) (= .cse143 .cse144) .cse145 (= |c_#NULL.offset| .cse140) (= .cse146 v_weq0_1) .cse147 .cse148) (let ((.cse151 (select .cse153 v_weq0_1))) (let ((.cse149 (select |c_old(#valid)| .cse151)) (.cse150 (select .cse152 v_weq0_1))) (and (= .cse149 |c_#NULL.offset|) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse142 (= .cse143 .cse150) .cse145 (= .cse151 .cse149) (= .cse150 .cse144) (= .cse138 v_weq0_1) .cse148 (= .cse141 .cse151) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse140 0) .cse139 (= c_main_~list~5.offset .cse140) .cse147 (= .cse146 .cse141)))) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (forall ((v_weq0_1 Int)) (let ((.cse166 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse154 (+ c_main_~list~5.offset 4))) (let ((.cse160 (select |c_#valid| c_main_~list~5.offset)) (.cse162 (select .cse166 .cse154)) (.cse167 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse159 (select |c_old(#valid)| 0))) (let ((.cse158 (not (= c_main_~list~5.base 0))) (.cse161 (not (= 0 c_main_~list~5.base))) (.cse164 (= 0 .cse159)) (.cse155 (select .cse167 v_weq0_1)) (.cse156 (select .cse167 .cse154)) (.cse163 (= .cse160 .cse162)) (.cse157 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (or (and (not (= v_weq0_1 .cse154)) (not (= v_weq0_1 0))) (= .cse155 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1)) (and (= .cse156 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse157 |c_#NULL.base|) .cse158 (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse157) (= .cse159 .cse160) .cse161 (= |c_#NULL.offset| .cse156) (= .cse162 v_weq0_1) .cse163 .cse164) (let ((.cse165 (select .cse166 v_weq0_1))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse158 (= .cse159 .cse165) (= .cse155 |c_#NULL.offset|) .cse161 (= .cse165 .cse160) (= .cse154 v_weq0_1) .cse164 (= .cse157 .cse155) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse156 0) (= c_main_~list~5.offset .cse156) .cse163 (= .cse162 .cse157)))))))) (not (= |c_#valid| |c_#length|)) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse194 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse189 (+ c_main_~list~5.offset 4))) (let ((.cse192 (select .cse194 .cse189)) (.cse168 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse180 (select |c_old(#valid)| v_weq0_1)) (.cse197 (select |c_#valid| v_weq0_1)) (.cse198 (select |c_old(#valid)| 0)) (.cse196 (select |c_#valid| c_main_~list~5.offset)) (.cse195 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse193 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse169 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse170 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse171 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse169)) (.cse173 (= .cse195 .cse193)) (.cse183 (= .cse198 .cse196)) (.cse174 (not (= 0 c_main_~list~5.base))) (.cse184 (= .cse197 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse185 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse186 (= 0 .cse198)) (.cse187 (= 1 .cse197)) (.cse175 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse188 (= (select .cse193 .cse189) .cse180)) (.cse177 (select .cse195 .cse189)) (.cse176 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse178 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse182 (= .cse194 .cse168)) (.cse190 (= .cse196 .cse192)) (.cse191 (= (select |c_#length| v_weq0_1) 8))) (or (= (select .cse168 v_weq1_1) (select .cse169 v_weq1_1)) (let ((.cse179 (select .cse195 v_weq1_1)) (.cse172 (select .cse194 v_weq1_1)) (.cse181 (select .cse193 v_weq1_1))) (and .cse170 .cse171 (= |c_#NULL.offset| .cse172) .cse173 .cse174 .cse175 .cse176 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse177 0) (= .cse178 .cse179) (= .cse180 .cse181) .cse182 (= c_main_~list~5.offset .cse177) (= .cse179 |c_#NULL.offset|) .cse183 .cse184 .cse185 .cse186 .cse187 .cse188 (= .cse172 |c_main_#t~malloc0.offset|) (= .cse181 |c_#NULL.base|) (= .cse189 v_weq1_1) .cse190 .cse191 (= .cse192 .cse178))) (and .cse170 .cse171 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse178 |c_#NULL.offset|) .cse173 (= c_main_~list~5.offset 0) .cse183 .cse174 .cse184 .cse185 .cse186 .cse187 .cse175 .cse188 (= .cse177 c_main_~list~5.offset) (= |c_#NULL.base| .cse177) .cse176 (= v_weq1_1 .cse178) (= .cse180 |c_#NULL.base|) .cse182 (= .cse192 v_weq1_1) .cse190 .cse191)))))) (= c_main_~list~5.offset .cse199) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse219 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse220 (+ c_main_~list~5.offset 4))) (let ((.cse223 (select .cse219 .cse220)) (.cse209 (select |c_old(#valid)| v_weq0_1)) (.cse225 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse228 (select |c_#valid| v_weq0_1)) (.cse229 (select |c_old(#valid)| 0)) (.cse226 (select |c_#valid| c_main_~list~5.offset)) (.cse224 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse227 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse210 (select .cse227 v_weq1_1)) (.cse200 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse201 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse212 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse202 (= .cse224 .cse227)) (.cse213 (= .cse229 .cse226)) (.cse203 (not (= 0 c_main_~list~5.base))) (.cse214 (= .cse228 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse215 (= .cse225 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse216 (= 0 .cse229)) (.cse217 (= 1 .cse228)) (.cse204 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse218 (= (select .cse227 .cse220) .cse209)) (.cse206 (select .cse224 .cse220)) (.cse205 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse207 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse211 (= .cse219 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse221 (= .cse226 .cse223)) (.cse222 (= (select |c_#length| v_weq0_1) 8))) (or (let ((.cse208 (select .cse224 v_weq1_1))) (and .cse200 .cse201 .cse202 .cse203 .cse204 .cse205 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse206 0) (= .cse207 .cse208) (= .cse209 .cse210) .cse211 (= c_main_~list~5.offset .cse206) (= .cse208 |c_#NULL.offset|) .cse212 .cse213 .cse214 .cse215 .cse216 .cse217 .cse218 (= |c_main_#t~malloc0.offset| (select .cse219 v_weq1_1)) (= .cse210 |c_#NULL.base|) (= .cse220 v_weq1_1) .cse221 .cse222 (= .cse223 .cse207))) (= (select .cse225 v_weq1_1) .cse210) (and .cse200 .cse201 .cse212 (= .cse207 |c_#NULL.offset|) .cse202 (= c_main_~list~5.offset 0) .cse213 .cse203 .cse214 .cse215 .cse216 .cse217 .cse204 .cse218 (= .cse206 c_main_~list~5.offset) (= |c_#NULL.base| .cse206) .cse205 (= v_weq1_1 .cse207) (= .cse209 |c_#NULL.base|) .cse211 (= .cse223 v_weq1_1) .cse221 .cse222)))))) (forall ((v_weq0_1 Int)) (or (= (select |c_old(#valid)| v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (let ((.cse235 (+ c_main_~list~5.offset 4))) (let ((.cse231 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse230 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse235)) (.cse233 (select |c_#valid| c_main_~list~5.offset)) (.cse234 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse235)) (.cse232 (select |c_old(#valid)| 0))) (and (= .cse230 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse231 |c_#NULL.base|) (not (= c_main_~list~5.base 0)) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse231) (= .cse232 .cse233) (not (= 0 c_main_~list~5.base)) (= |c_#NULL.offset| .cse230) (= .cse234 v_weq0_1) (= .cse233 .cse234) (= 0 .cse232)))) (not (= v_weq0_1 0)))) (not (= |c_#length| |c_old(#valid)|)) (forall ((v_weq0_1 Int)) (let ((.cse245 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse236 (select .cse245 v_weq0_1))) (or (not (= v_weq0_1 0)) (= .cse236 (select |c_old(#valid)| v_weq0_1)) (let ((.cse240 (+ c_main_~list~5.offset 4)) (.cse244 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse238 (select .cse244 v_weq0_1)) (.cse237 (select |c_old(#valid)| 0)) (.cse242 (select .cse245 .cse240)) (.cse239 (select |c_#valid| c_main_~list~5.offset)) (.cse243 (select .cse244 .cse240)) (.cse241 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse237 .cse238) (= .cse236 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse238 .cse239) (= .cse240 v_weq0_1) (= 0 .cse237) (= .cse241 .cse236) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse242 0) (= c_main_~list~5.offset .cse242) (= .cse239 .cse243) (= .cse243 .cse241)))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse265 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse266 (+ c_main_~list~5.offset 4))) (let ((.cse269 (select .cse265 .cse266)) (.cse255 (select |c_old(#valid)| v_weq0_1)) (.cse274 (select |c_#valid| v_weq0_1)) (.cse275 (select |c_old(#valid)| 0)) (.cse272 (select |c_#valid| c_main_~list~5.offset)) (.cse270 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse271 (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (.cse273 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse256 (select .cse273 v_weq1_1)) (.cse246 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse247 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse271)) (.cse258 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse248 (= .cse270 .cse273)) (.cse259 (= .cse275 .cse272)) (.cse249 (not (= 0 c_main_~list~5.base))) (.cse260 (= .cse274 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse261 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse262 (= 0 .cse275)) (.cse263 (= 1 .cse274)) (.cse250 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse264 (= (select .cse273 .cse266) .cse255)) (.cse252 (select .cse270 .cse266)) (.cse251 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse253 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse257 (= .cse265 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse267 (= .cse272 .cse269)) (.cse268 (= (select |c_#length| v_weq0_1) 8))) (or (let ((.cse254 (select .cse270 v_weq1_1))) (and .cse246 .cse247 .cse248 .cse249 .cse250 .cse251 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse252 0) (= .cse253 .cse254) (= .cse255 .cse256) .cse257 (= c_main_~list~5.offset .cse252) (= .cse254 |c_#NULL.offset|) .cse258 .cse259 .cse260 .cse261 .cse262 .cse263 .cse264 (= |c_main_#t~malloc0.offset| (select .cse265 v_weq1_1)) (= .cse256 |c_#NULL.base|) (= .cse266 v_weq1_1) .cse267 .cse268 (= .cse269 .cse253))) (= .cse256 (select .cse271 v_weq1_1)) (not (= v_weq0_1 c_main_~list~5.base)) (and .cse246 .cse247 .cse258 (= .cse253 |c_#NULL.offset|) .cse248 (= c_main_~list~5.offset 0) .cse259 .cse249 .cse260 .cse261 .cse262 .cse263 .cse250 .cse264 (= .cse252 c_main_~list~5.offset) (= |c_#NULL.base| .cse252) .cse251 (= v_weq1_1 .cse253) (= .cse255 |c_#NULL.base|) .cse257 (= .cse269 v_weq1_1) .cse267 .cse268) (and (not (= v_weq1_1 .cse266)) (not (= v_weq1_1 0)))))))) (forall ((v_weq0_1 Int)) (let ((.cse285 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse276 (select .cse285 v_weq0_1))) (or (= .cse276 (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse280 (+ c_main_~list~5.offset 4)) (.cse284 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse278 (select .cse284 v_weq0_1)) (.cse277 (select |c_old(#valid)| 0)) (.cse282 (select .cse285 .cse280)) (.cse279 (select |c_#valid| c_main_~list~5.offset)) (.cse283 (select .cse284 .cse280)) (.cse281 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (not (= c_main_~list~5.base 0)) (= .cse277 .cse278) (= .cse276 |c_#NULL.offset|) (not (= 0 c_main_~list~5.base)) (= .cse278 .cse279) (= .cse280 v_weq0_1) (= 0 .cse277) (= .cse281 .cse276) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse282 0) (= c_main_~list~5.offset .cse282) (= .cse279 .cse283) (= .cse283 .cse281)))))))) (forall ((v_weq0_1 Int)) (let ((.cse299 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse297 (+ c_main_~list~5.offset 4))) (let ((.cse290 (select |c_#valid| c_main_~list~5.offset)) (.cse292 (select .cse299 .cse297)) (.cse298 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse289 (select |c_old(#valid)| 0))) (let ((.cse288 (not (= c_main_~list~5.base 0))) (.cse291 (not (= 0 c_main_~list~5.base))) (.cse295 (select .cse299 v_weq0_1)) (.cse294 (= 0 .cse289)) (.cse286 (select .cse298 .cse297)) (.cse293 (= .cse290 .cse292)) (.cse287 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (or (and (= .cse286 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse287 |c_#NULL.base|) .cse288 (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse287) (= .cse289 .cse290) .cse291 (= |c_#NULL.offset| .cse286) (= .cse292 v_weq0_1) .cse293 .cse294) (= .cse295 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1)) (let ((.cse296 (select .cse298 v_weq0_1))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse288 (= .cse289 .cse295) (= .cse296 |c_#NULL.offset|) .cse291 (= .cse295 .cse290) (= .cse297 v_weq0_1) .cse294 (= .cse287 .cse296) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse286 0) (= c_main_~list~5.offset .cse286) .cse293 (= .cse292 .cse287)))))))) (= .cse300 .cse301) (= |c_#NULL.offset| c_main_~list~5.offset) (= 0 .cse300) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 (+ c_main_~list~5.offset 4))) (not (= v_weq0_1 0))))) (= .cse302 |c_#NULL.base|) (= .cse199 |c_main_#t~malloc0.offset|) (forall ((v_weq0_1 Int)) (let ((.cse316 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse304 (+ c_main_~list~5.offset 4))) (let ((.cse309 (select |c_#valid| c_main_~list~5.offset)) (.cse311 (select .cse316 .cse304)) (.cse315 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse308 (select |c_old(#valid)| 0))) (let ((.cse307 (not (= c_main_~list~5.base 0))) (.cse310 (not (= 0 c_main_~list~5.base))) (.cse303 (select .cse316 v_weq0_1)) (.cse313 (= 0 .cse308)) (.cse305 (select .cse315 .cse304)) (.cse312 (= .cse309 .cse311)) (.cse306 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (or (= .cse303 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 .cse304)) (not (= v_weq0_1 0))) (and (= .cse305 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse306 |c_#NULL.base|) .cse307 (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse306) (= .cse308 .cse309) .cse310 (= |c_#NULL.offset| .cse305) (= .cse311 v_weq0_1) .cse312 .cse313) (let ((.cse314 (select .cse315 v_weq0_1))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) .cse307 (= .cse308 .cse303) (= .cse314 |c_#NULL.offset|) .cse310 (= .cse303 .cse309) (= .cse304 v_weq0_1) .cse313 (= .cse306 .cse314) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse305 0) (= c_main_~list~5.offset .cse305) .cse312 (= .cse311 .cse306)))))))) (forall ((v_weq0_1 Int)) (or (let ((.cse322 (+ c_main_~list~5.offset 4))) (let ((.cse318 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse317 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse322)) (.cse320 (select |c_#valid| c_main_~list~5.offset)) (.cse321 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse322)) (.cse319 (select |c_old(#valid)| 0))) (and (= .cse317 c_main_~list~5.offset) (= |c_#NULL.base| |c_#NULL.offset|) (= .cse318 |c_#NULL.base|) (not (= c_main_~list~5.base 0)) (= c_main_~list~5.offset |c_main_#t~malloc0.offset|) (= v_weq0_1 .cse318) (= .cse319 .cse320) (not (= 0 c_main_~list~5.base)) (= |c_#NULL.offset| .cse317) (= .cse321 v_weq0_1) (= .cse320 .cse321) (= 0 .cse319)))) (= (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))) (= .cse301 .cse323) (= .cse323 .cse302) (= 1 (select |c_#valid| |c_main_#t~malloc0.base|)) (not (= |c_#valid| |c_old(#valid)|))))) is different from false [2018-01-21 10:54:06,795 WARN L1007 $PredicateComparison]: unable to prove that (let ((.cse341 (+ c_main_~list~5.offset 4))) (let ((.cse244 (select |c_old(#valid)| 0)) (.cse144 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse341)) (.cse245 (select |c_#valid| c_main_~list~5.offset)) (.cse340 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse341)) (.cse0 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= .cse0 c_main_~end~5.offset) (forall ((v_weq0_1 Int)) (let ((.cse15 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse13 (+ c_main_~list~5.offset 4))) (let ((.cse7 (select |c_#valid| c_main_~list~5.offset)) (.cse8 (select .cse15 .cse13)) (.cse14 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse6 (select |c_old(#valid)| 0)) (.cse5 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (let ((.cse2 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse3 (= .cse5 c_main_~end~5.offset)) (.cse10 (= 0 .cse6)) (.cse4 (not (= 0 |c_main_#t~malloc0.base|))) (.cse1 (select .cse14 .cse13)) (.cse9 (= .cse7 .cse8)) (.cse11 (select .cse15 v_weq0_1))) (or (and (= .cse1 c_main_~list~5.offset) .cse2 .cse3 (= |c_#NULL.base| .cse1) .cse4 (= v_weq0_1 .cse5) (= c_main_~list~5.offset 0) (= .cse6 .cse7) (= c_main_~end~5.offset |c_#NULL.offset|) (= .cse8 v_weq0_1) .cse9 .cse10) (let ((.cse12 (select .cse14 v_weq0_1))) (and .cse2 .cse3 (= .cse6 .cse11) (= .cse12 |c_#NULL.offset|) (= .cse11 .cse7) (= .cse13 v_weq0_1) (= c_main_~end~5.offset .cse12) .cse10 .cse4 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse1 0) (= c_main_~list~5.offset .cse1) .cse9 (= .cse8 .cse5))) (= .cse11 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1))))))) (not (= 0 c_main_~end~5.base)) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse21 (+ c_main_~list~5.offset 4))) (let ((.cse16 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse17 (select |c_old(#valid)| 0)) (.cse19 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse21)) (.cse18 (select |c_#valid| c_main_~list~5.offset)) (.cse20 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse21))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse16 c_main_~end~5.offset) (= v_weq0_1 .cse16) (= c_main_~list~5.offset 0) (= .cse17 .cse18) (= c_main_~end~5.offset |c_#NULL.offset|) (= 0 .cse17) (= .cse19 c_main_~list~5.offset) (= |c_#NULL.base| .cse19) (not (= 0 |c_main_#t~malloc0.base|)) (not (= |c_main_#t~malloc0.base| 0)) (= .cse20 v_weq0_1) (= .cse18 .cse20)))))) (forall ((v_weq0_1 Int)) (let ((.cse30 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse24 (select .cse30 v_weq0_1))) (or (let ((.cse27 (+ c_main_~list~5.offset 4)) (.cse31 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse25 (select .cse31 v_weq0_1)) (.cse23 (select |c_old(#valid)| 0)) (.cse28 (select .cse31 .cse27)) (.cse26 (select |c_#valid| c_main_~list~5.offset)) (.cse29 (select .cse30 .cse27)) (.cse22 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse22 c_main_~end~5.offset) (= .cse23 .cse24) (= .cse25 |c_#NULL.offset|) (= .cse24 .cse26) (= .cse27 v_weq0_1) (= c_main_~end~5.offset .cse25) (= 0 .cse23) (not (= 0 |c_main_#t~malloc0.base|)) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse28 0) (not (= |c_main_#t~malloc0.base| 0)) (= c_main_~list~5.offset .cse28) (= .cse26 .cse29) (= .cse29 .cse22)))) (= .cse24 (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int)) (let ((.cse47 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse33 (+ c_main_~list~5.offset 4))) (let ((.cse38 (select |c_#valid| c_main_~list~5.offset)) (.cse44 (select .cse47 .cse33)) (.cse46 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse36 (select |c_old(#valid)| 0)) (.cse45 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (let ((.cse32 (select .cse47 v_weq0_1)) (.cse34 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse35 (= .cse45 c_main_~end~5.offset)) (.cse39 (= 0 .cse36)) (.cse41 (select .cse46 .cse33)) (.cse40 (not (= 0 |c_main_#t~malloc0.base|))) (.cse42 (not (= |c_main_#t~malloc0.base| 0))) (.cse43 (= .cse38 .cse44))) (or (= .cse32 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 .cse33)) (not (= v_weq0_1 0))) (let ((.cse37 (select .cse46 v_weq0_1))) (and .cse34 .cse35 (= .cse36 .cse32) (= .cse37 |c_#NULL.offset|) (= .cse32 .cse38) (= .cse33 v_weq0_1) (= c_main_~end~5.offset .cse37) .cse39 .cse40 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse41 0) .cse42 (= c_main_~list~5.offset .cse41) .cse43 (= .cse44 .cse45))) (and .cse34 .cse35 (= v_weq0_1 .cse45) (= c_main_~list~5.offset 0) (= .cse36 .cse38) (= c_main_~end~5.offset |c_#NULL.offset|) .cse39 (= .cse41 c_main_~list~5.offset) (= |c_#NULL.base| .cse41) .cse40 .cse42 (= .cse44 v_weq0_1) .cse43)))))) (forall ((v_weq0_1 Int)) (let ((.cse61 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse48 (+ c_main_~list~5.offset 4))) (let ((.cse56 (select |c_#valid| c_main_~list~5.offset)) (.cse57 (select .cse61 .cse48)) (.cse55 (select |c_old(#valid)| 0)) (.cse62 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse54 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (let ((.cse51 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse52 (= .cse54 c_main_~end~5.offset)) (.cse49 (select .cse62 v_weq0_1)) (.cse59 (= 0 .cse55)) (.cse53 (not (= 0 |c_main_#t~malloc0.base|))) (.cse50 (select .cse62 .cse48)) (.cse58 (= .cse56 .cse57))) (or (and (not (= v_weq0_1 .cse48)) (not (= v_weq0_1 0))) (= .cse49 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1)) (and (= .cse50 c_main_~list~5.offset) .cse51 .cse52 (= |c_#NULL.base| .cse50) .cse53 (= v_weq0_1 .cse54) (= c_main_~list~5.offset 0) (= .cse55 .cse56) (= c_main_~end~5.offset |c_#NULL.offset|) (= .cse57 v_weq0_1) .cse58 .cse59) (let ((.cse60 (select .cse61 v_weq0_1))) (and .cse51 .cse52 (= .cse55 .cse60) (= .cse49 |c_#NULL.offset|) (= .cse60 .cse56) (= .cse48 v_weq0_1) (= c_main_~end~5.offset .cse49) .cse59 .cse53 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse50 0) (= c_main_~list~5.offset .cse50) .cse58 (= .cse57 .cse54)))))))) (forall ((v_weq0_1 Int)) (let ((.cse76 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse75 (+ c_main_~list~5.offset 4))) (let ((.cse69 (select |c_#valid| c_main_~list~5.offset)) (.cse70 (select .cse76 .cse75)) (.cse77 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse68 (select |c_old(#valid)| 0)) (.cse67 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (let ((.cse64 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse65 (= .cse67 c_main_~end~5.offset)) (.cse72 (= 0 .cse68)) (.cse66 (not (= 0 |c_main_#t~malloc0.base|))) (.cse63 (select .cse77 .cse75)) (.cse71 (= .cse69 .cse70)) (.cse74 (select .cse77 v_weq0_1))) (or (and (= .cse63 c_main_~list~5.offset) .cse64 .cse65 (= |c_#NULL.base| .cse63) .cse66 (= v_weq0_1 .cse67) (= c_main_~list~5.offset 0) (= .cse68 .cse69) (= c_main_~end~5.offset |c_#NULL.offset|) (= .cse70 v_weq0_1) .cse71 .cse72) (let ((.cse73 (select .cse76 v_weq0_1))) (and .cse64 .cse65 (= .cse68 .cse73) (= .cse74 |c_#NULL.offset|) (= .cse73 .cse69) (= .cse75 v_weq0_1) (= c_main_~end~5.offset .cse74) .cse72 .cse66 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse63 0) (= c_main_~list~5.offset .cse63) .cse71 (= .cse70 .cse67))) (= .cse74 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse106 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse100 (+ c_main_~list~5.offset 4))) (let ((.cse103 (select .cse106 .cse100)) (.cse90 (select |c_old(#valid)| v_weq0_1)) (.cse107 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse110 (select |c_#valid| v_weq0_1)) (.cse111 (select |c_old(#valid)| 0)) (.cse109 (select |c_#valid| c_main_~list~5.offset)) (.cse108 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse104 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse105 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse79 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse80 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse82 (= .cse104 .cse105)) (.cse83 (not (= 0 c_main_~end~5.base))) (.cse84 (= c_main_~end~5.offset |c_#NULL.offset|)) (.cse85 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse87 (select .cse104 .cse100)) (.cse86 (= c_main_~list~5.base c_main_~end~5.base)) (.cse78 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse92 (= .cse106 .cse108)) (.cse93 (= .cse111 .cse109)) (.cse94 (= .cse110 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse95 (not (= c_main_~end~5.base 0))) (.cse96 (= .cse107 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse97 (= 0 .cse111)) (.cse98 (= 1 .cse110)) (.cse99 (= (select .cse105 .cse100) .cse90)) (.cse88 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse101 (= .cse109 .cse103)) (.cse102 (= (select |c_#length| v_weq0_1) 8))) (or (not .cse78) (let ((.cse81 (select .cse106 v_weq1_1)) (.cse91 (select .cse105 v_weq1_1)) (.cse89 (select .cse104 v_weq1_1))) (and .cse79 .cse80 (= |c_#NULL.offset| .cse81) .cse82 .cse83 .cse84 .cse85 .cse86 .cse78 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse87 0) (= .cse88 .cse89) (= .cse90 .cse91) .cse92 (= c_main_~list~5.offset .cse87) .cse93 .cse94 .cse95 .cse96 .cse97 .cse98 .cse99 (= .cse81 |c_main_#t~malloc0.offset|) (= .cse91 |c_#NULL.base|) (= .cse100 v_weq1_1) (= .cse89 c_main_~end~5.offset) .cse101 .cse102 (= .cse103 .cse88))) (and (not (= v_weq1_1 .cse100)) (not (= v_weq1_1 0))) (= (select .cse107 v_weq1_1) (select .cse108 v_weq1_1)) (and .cse79 .cse80 (= .cse88 c_main_~end~5.offset) .cse82 .cse83 .cse84 .cse85 (= .cse87 c_main_~list~5.offset) (= |c_#NULL.base| .cse87) .cse86 .cse78 (= .cse90 |c_#NULL.base|) .cse92 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= c_main_~list~5.offset 0) .cse93 .cse94 .cse95 .cse96 .cse97 .cse98 .cse99 (= v_weq1_1 .cse88) (= .cse103 v_weq1_1) .cse101 .cse102)))))) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= |c_#NULL.base| |c_#NULL.offset|) (= c_main_~list~5.base c_main_~end~5.base) (not (= |c_#valid| |c_#length|)) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse137 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse138 (+ c_main_~list~5.offset 4))) (let ((.cse133 (select .cse137 .cse138)) (.cse124 (select |c_old(#valid)| v_weq0_1)) (.cse112 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse142 (select |c_#valid| v_weq0_1)) (.cse143 (select |c_old(#valid)| 0)) (.cse140 (select |c_#valid| c_main_~list~5.offset)) (.cse139 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse141 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse114 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse115 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse117 (= .cse139 .cse141)) (.cse118 (not (= 0 c_main_~end~5.base))) (.cse119 (= c_main_~end~5.offset |c_#NULL.offset|)) (.cse120 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse122 (= c_main_~list~5.base c_main_~end~5.base)) (.cse123 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse125 (= .cse137 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse121 (select .cse139 .cse138)) (.cse126 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse127 (= .cse143 .cse140)) (.cse128 (= .cse142 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse129 (= .cse112 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse130 (= 0 .cse143)) (.cse131 (= 1 .cse142)) (.cse132 (= (select .cse141 .cse138) .cse124)) (.cse113 (select .cse141 v_weq1_1)) (.cse134 (= .cse140 .cse133)) (.cse135 (= (select |c_#length| v_weq0_1) 8)) (.cse116 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (or (= (select .cse112 v_weq1_1) .cse113) (and .cse114 .cse115 (= .cse116 c_main_~end~5.offset) .cse117 .cse118 .cse119 .cse120 (= .cse121 c_main_~list~5.offset) (= |c_#NULL.base| .cse121) .cse122 .cse123 (= .cse124 |c_#NULL.base|) .cse125 .cse126 (= c_main_~list~5.offset 0) .cse127 .cse128 .cse129 .cse130 .cse131 .cse132 (= v_weq1_1 .cse116) (= .cse133 v_weq1_1) .cse134 .cse135) (let ((.cse136 (select .cse139 v_weq1_1))) (and .cse114 .cse115 .cse117 .cse118 .cse119 .cse120 .cse122 .cse123 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse121 0) (= .cse116 .cse136) (= .cse124 .cse113) .cse125 (= c_main_~list~5.offset .cse121) .cse126 .cse127 .cse128 .cse129 .cse130 .cse131 .cse132 (= |c_main_#t~malloc0.offset| (select .cse137 v_weq1_1)) (= .cse113 |c_#NULL.base|) (= .cse138 v_weq1_1) (= .cse136 c_main_~end~5.offset) .cse134 .cse135 (= .cse133 .cse116)))))))) (= c_main_~list~5.offset .cse144) (forall ((v_weq0_1 Int)) (let ((.cse146 (select |c_#valid| v_weq0_1)) (.cse145 (select |c_old(#valid)| v_weq0_1))) (or (= .cse145 .cse146) (let ((.cse151 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse148 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse154 (+ c_main_~list~5.offset 4))) (let ((.cse150 (select .cse148 .cse154)) (.cse152 (select |c_old(#valid)| 0)) (.cse149 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse153 (select |c_#valid| c_main_~list~5.offset)) (.cse155 (select .cse151 .cse154)) (.cse147 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse147 c_main_~end~5.offset) (= .cse148 .cse149) (not (= 0 c_main_~end~5.base)) (= c_main_~end~5.offset |c_#NULL.offset|) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= c_main_~list~5.base c_main_~end~5.base) (= v_weq0_1 |c_main_#t~malloc0.base|) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse150 0) (= .cse145 |c_#NULL.base|) (= .cse151 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= c_main_~list~5.offset .cse150) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse152 .cse153) (= .cse146 (select |c_#valid| |c_main_#t~malloc0.base|)) (not (= c_main_~end~5.base 0)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 0 .cse152) (= 1 .cse146) (= (select .cse149 .cse154) .cse145) (= .cse153 .cse155) (= (select |c_#length| v_weq0_1) 8) (= .cse155 .cse147))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse185 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse179 (+ c_main_~list~5.offset 4))) (let ((.cse182 (select .cse185 .cse179)) (.cse170 (select |c_old(#valid)| v_weq0_1)) (.cse187 (select |c_#valid| v_weq0_1)) (.cse188 (select |c_old(#valid)| 0)) (.cse186 (select |c_#valid| c_main_~list~5.offset)) (.cse156 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse183 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse184 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse157 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse158 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse159 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse157)) (.cse161 (= .cse183 .cse184)) (.cse162 (not (= 0 c_main_~end~5.base))) (.cse163 (= c_main_~end~5.offset |c_#NULL.offset|)) (.cse164 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse167 (select .cse183 .cse179)) (.cse165 (= c_main_~list~5.base c_main_~end~5.base)) (.cse166 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse172 (= .cse185 .cse156)) (.cse173 (= .cse188 .cse186)) (.cse174 (= .cse187 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse175 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse176 (= 0 .cse188)) (.cse177 (= 1 .cse187)) (.cse178 (= (select .cse184 .cse179) .cse170)) (.cse168 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse180 (= .cse186 .cse182)) (.cse181 (= (select |c_#length| v_weq0_1) 8))) (or (= (select .cse156 v_weq1_1) (select .cse157 v_weq1_1)) (let ((.cse160 (select .cse185 v_weq1_1)) (.cse171 (select .cse184 v_weq1_1)) (.cse169 (select .cse183 v_weq1_1))) (and .cse158 .cse159 (= |c_#NULL.offset| .cse160) .cse161 .cse162 .cse163 .cse164 .cse165 .cse166 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse167 0) (= .cse168 .cse169) (= .cse170 .cse171) .cse172 (= c_main_~list~5.offset .cse167) .cse173 .cse174 .cse175 .cse176 .cse177 .cse178 (= .cse160 |c_main_#t~malloc0.offset|) (= .cse171 |c_#NULL.base|) (= .cse179 v_weq1_1) (= .cse169 c_main_~end~5.offset) .cse180 .cse181 (= .cse182 .cse168))) (and .cse158 .cse159 (= .cse168 c_main_~end~5.offset) .cse161 .cse162 .cse163 .cse164 (= .cse167 c_main_~list~5.offset) (= |c_#NULL.base| .cse167) .cse165 .cse166 (= .cse170 |c_#NULL.base|) .cse172 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= c_main_~list~5.offset 0) .cse173 .cse174 .cse175 .cse176 .cse177 .cse178 (= v_weq1_1 .cse168) (= .cse182 v_weq1_1) .cse180 .cse181)))))) (not (= |c_#length| |c_old(#valid)|)) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse220 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse214 (+ c_main_~list~5.offset 4))) (let ((.cse218 (select .cse220 .cse214)) (.cse223 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse226 (select |c_#valid| v_weq0_1)) (.cse227 (select |c_old(#valid)| 0)) (.cse225 (select |c_#valid| c_main_~list~5.offset)) (.cse219 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse222 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse221 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse224 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse215 (not (= v_weq1_1 0))) (.cse190 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse191 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse224)) (.cse193 (= .cse222 .cse221)) (.cse195 (not (= 0 c_main_~end~5.base))) (.cse196 (= c_main_~end~5.offset |c_#NULL.offset|)) (.cse197 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse199 (select .cse222 .cse214)) (.cse198 (= c_main_~list~5.base c_main_~end~5.base)) (.cse189 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse204 (= .cse220 .cse219)) (.cse208 (= .cse227 .cse225)) (.cse209 (= .cse226 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse210 (not (= c_main_~end~5.base 0))) (.cse211 (= .cse223 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse212 (= 0 .cse227)) (.cse213 (= 1 .cse226)) (.cse206 (select .cse221 .cse214)) (.cse202 (select |c_old(#valid)| v_weq0_1)) (.cse200 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse216 (= .cse225 .cse218)) (.cse217 (= (select |c_#length| v_weq0_1) 8))) (or (not .cse189) (let ((.cse201 (select .cse222 v_weq1_1)) (.cse203 (select .cse221 v_weq1_1))) (let ((.cse207 (select |c_old(#valid)| .cse203)) (.cse194 (select |c_old(#valid)| .cse201)) (.cse192 (select .cse220 v_weq1_1)) (.cse205 (select .cse219 .cse214))) (and .cse190 .cse191 (= |c_#NULL.offset| .cse192) .cse193 (= |c_#NULL.base| .cse194) .cse195 .cse196 .cse197 .cse198 .cse189 (= .cse199 0) (= .cse200 .cse201) (= .cse202 .cse203) .cse204 (= c_main_~list~5.offset .cse199) (= .cse205 |c_#NULL.base|) (= .cse206 .cse207) .cse208 (= .cse207 .cse202) .cse209 (= .cse194 c_main_~list~5.offset) .cse210 .cse211 .cse212 .cse213 (= .cse192 |c_main_#t~malloc0.offset|) (= .cse214 v_weq1_1) .cse215 (= .cse201 c_main_~end~5.offset) .cse216 (= .cse203 .cse205) .cse217 (= .cse218 .cse200)))) (= (select .cse223 v_weq1_1) (select .cse224 v_weq1_1)) (and (not (= v_weq1_1 .cse214)) .cse215) (and .cse190 .cse191 (= .cse200 c_main_~end~5.offset) .cse193 .cse195 .cse196 .cse197 (= .cse199 c_main_~list~5.offset) (= |c_#NULL.base| .cse199) .cse198 .cse189 (= .cse202 |c_#NULL.base|) .cse204 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= c_main_~list~5.offset 0) .cse208 .cse209 .cse210 .cse211 .cse212 .cse213 (= .cse206 .cse202) (= v_weq1_1 .cse200) (= .cse218 v_weq1_1) .cse216 .cse217)))))) (forall ((v_weq0_1 Int)) (let ((.cse237 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse231 (select .cse237 v_weq0_1))) (or (let ((.cse233 (+ c_main_~list~5.offset 4)) (.cse236 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse230 (select .cse236 v_weq0_1)) (.cse229 (select |c_old(#valid)| 0)) (.cse234 (select .cse237 .cse233)) (.cse232 (select |c_#valid| c_main_~list~5.offset)) (.cse235 (select .cse236 .cse233)) (.cse228 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse228 c_main_~end~5.offset) (= .cse229 .cse230) (= .cse231 |c_#NULL.offset|) (= .cse230 .cse232) (= .cse233 v_weq0_1) (= c_main_~end~5.offset .cse231) (= 0 .cse229) (not (= 0 |c_main_#t~malloc0.base|)) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse234 0) (not (= |c_main_#t~malloc0.base| 0)) (= c_main_~list~5.offset .cse234) (= .cse232 .cse235) (= .cse235 .cse228)))) (not (= v_weq0_1 0)) (= .cse231 (select |c_old(#valid)| v_weq0_1)))))) (= c_main_~end~5.offset |c_#NULL.base|) (forall ((v_weq0_1 Int)) (or (= (select |c_old(#valid)| v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse243 (+ c_main_~list~5.offset 4))) (let ((.cse238 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse239 (select |c_old(#valid)| 0)) (.cse241 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse243)) (.cse240 (select |c_#valid| c_main_~list~5.offset)) (.cse242 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse243))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse238 c_main_~end~5.offset) (= v_weq0_1 .cse238) (= c_main_~list~5.offset 0) (= .cse239 .cse240) (= c_main_~end~5.offset |c_#NULL.offset|) (= 0 .cse239) (= .cse241 c_main_~list~5.offset) (= |c_#NULL.base| .cse241) (not (= 0 |c_main_#t~malloc0.base|)) (not (= |c_main_#t~malloc0.base| 0)) (= .cse242 v_weq0_1) (= .cse240 .cse242)))))) (= .cse244 .cse245) (forall ((v_weq0_1 Int)) (let ((.cse254 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse246 (select .cse254 v_weq0_1))) (or (= .cse246 (select |c_old(#valid)| v_weq0_1)) (let ((.cse251 (+ c_main_~list~5.offset 4)) (.cse255 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse249 (select .cse255 v_weq0_1)) (.cse248 (select |c_old(#valid)| 0)) (.cse252 (select .cse255 .cse251)) (.cse250 (select |c_#valid| c_main_~list~5.offset)) (.cse253 (select .cse254 .cse251)) (.cse247 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse247 c_main_~end~5.offset) (= .cse248 .cse246) (= .cse249 |c_#NULL.offset|) (= .cse246 .cse250) (= .cse251 v_weq0_1) (= c_main_~end~5.offset .cse249) (= 0 .cse248) (not (= 0 |c_main_#t~malloc0.base|)) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse252 0) (not (= |c_main_#t~malloc0.base| 0)) (= c_main_~list~5.offset .cse252) (= .cse250 .cse253) (= .cse253 .cse247)))) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int)) (let ((.cse267 (select |c_#length| v_weq0_1))) (or (let ((.cse265 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse257 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse262 (+ c_main_~list~5.offset 4))) (let ((.cse259 (select |c_old(#valid)| 0)) (.cse261 (select |c_#valid| v_weq0_1)) (.cse258 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse264 (select .cse257 .cse262)) (.cse263 (select |c_old(#valid)| v_weq0_1)) (.cse260 (select |c_#valid| c_main_~list~5.offset)) (.cse266 (select .cse265 .cse262)) (.cse256 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= v_weq0_1 c_main_~list~5.base) (= .cse256 c_main_~end~5.offset) (= .cse257 .cse258) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (not (= 0 c_main_~end~5.base)) (= c_main_~list~5.offset 0) (= .cse259 .cse260) (= c_main_~end~5.offset |c_#NULL.offset|) (= |c_main_#t~malloc0.base| c_main_~end~5.base) (= .cse261 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 0 .cse259) (= 1 .cse261) (= (select .cse258 .cse262) .cse263) (= .cse264 c_main_~list~5.offset) (= |c_#NULL.base| .cse264) (= .cse263 |c_#NULL.base|) (= .cse265 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= .cse260 .cse266) (= .cse267 8) (= .cse266 .cse256)))) (= .cse267 (select |c_old(#length)| v_weq0_1))))) (= |c_#NULL.offset| c_main_~list~5.offset) (= 0 .cse244) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 (+ c_main_~list~5.offset 4))) (not (= v_weq0_1 0))))) (forall ((v_weq0_1 Int)) (let ((.cse284 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse275 (+ c_main_~list~5.offset 4))) (let ((.cse274 (select |c_#valid| c_main_~list~5.offset)) (.cse282 (select .cse284 .cse275)) (.cse285 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse271 (select |c_old(#valid)| 0)) (.cse283 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (let ((.cse280 (not (= v_weq0_1 0))) (.cse269 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse270 (= .cse283 c_main_~end~5.offset)) (.cse276 (= 0 .cse271)) (.cse278 (select .cse285 .cse275)) (.cse277 (not (= 0 |c_main_#t~malloc0.base|))) (.cse279 (not (= |c_main_#t~malloc0.base| 0))) (.cse281 (= .cse274 .cse282))) (or (let ((.cse273 (select .cse285 v_weq0_1))) (let ((.cse268 (select |c_old(#valid)| .cse273)) (.cse272 (select .cse284 v_weq0_1))) (and (= .cse268 |c_#NULL.offset|) .cse269 .cse270 (= .cse271 .cse272) (= .cse273 .cse268) (= .cse272 .cse274) (= .cse275 v_weq0_1) (= c_main_~end~5.offset .cse273) .cse276 .cse277 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse278 0) .cse279 .cse280 (= c_main_~list~5.offset .cse278) .cse281 (= .cse282 .cse283)))) (and (not (= v_weq0_1 .cse275)) .cse280) (and .cse269 .cse270 (= v_weq0_1 .cse283) (= c_main_~list~5.offset 0) (= .cse271 .cse274) (= c_main_~end~5.offset |c_#NULL.offset|) .cse276 (= .cse278 c_main_~list~5.offset) (= |c_#NULL.base| .cse278) .cse277 .cse279 (= .cse282 v_weq0_1) .cse281) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse291 (+ c_main_~list~5.offset 4))) (let ((.cse286 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse287 (select |c_old(#valid)| 0)) (.cse289 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse291)) (.cse288 (select |c_#valid| c_main_~list~5.offset)) (.cse290 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse291))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse286 c_main_~end~5.offset) (= v_weq0_1 .cse286) (= c_main_~list~5.offset 0) (= .cse287 .cse288) (= c_main_~end~5.offset |c_#NULL.offset|) (= 0 .cse287) (= .cse289 c_main_~list~5.offset) (= |c_#NULL.base| .cse289) (not (= 0 |c_main_#t~malloc0.base|)) (not (= |c_main_#t~malloc0.base| 0)) (= .cse290 v_weq0_1) (= .cse288 .cse290)))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse297 (+ c_main_~list~5.offset 4))) (let ((.cse292 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse293 (select |c_old(#valid)| 0)) (.cse295 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse297)) (.cse294 (select |c_#valid| c_main_~list~5.offset)) (.cse296 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse297))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse292 c_main_~end~5.offset) (= v_weq0_1 .cse292) (= c_main_~list~5.offset 0) (= .cse293 .cse294) (= c_main_~end~5.offset |c_#NULL.offset|) (= 0 .cse293) (= .cse295 c_main_~list~5.offset) (= |c_#NULL.base| .cse295) (not (= 0 |c_main_#t~malloc0.base|)) (not (= |c_main_#t~malloc0.base| 0)) (= .cse296 v_weq0_1) (= .cse294 .cse296)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse324 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse301 (+ c_main_~list~5.offset 4))) (let ((.cse320 (select .cse324 .cse301)) (.cse311 (select |c_old(#valid)| v_weq0_1)) (.cse328 (select |c_#valid| v_weq0_1)) (.cse329 (select |c_old(#valid)| 0)) (.cse326 (select |c_#valid| c_main_~list~5.offset)) (.cse325 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse327 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse300 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse302 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse303 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse300)) (.cse305 (= .cse325 .cse327)) (.cse306 (not (= 0 c_main_~end~5.base))) (.cse307 (= c_main_~end~5.offset |c_#NULL.offset|)) (.cse308 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse310 (= c_main_~list~5.base c_main_~end~5.base)) (.cse298 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse312 (= .cse324 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse309 (select .cse325 .cse301)) (.cse313 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse314 (= .cse329 .cse326)) (.cse315 (= .cse328 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse316 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse317 (= 0 .cse329)) (.cse318 (= 1 .cse328)) (.cse319 (= (select .cse327 .cse301) .cse311)) (.cse299 (select .cse327 v_weq1_1)) (.cse321 (= .cse326 .cse320)) (.cse322 (= (select |c_#length| v_weq0_1) 8)) (.cse304 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (or (not .cse298) (= .cse299 (select .cse300 v_weq1_1)) (and (not (= v_weq1_1 .cse301)) (not (= v_weq1_1 0))) (and .cse302 .cse303 (= .cse304 c_main_~end~5.offset) .cse305 .cse306 .cse307 .cse308 (= .cse309 c_main_~list~5.offset) (= |c_#NULL.base| .cse309) .cse310 .cse298 (= .cse311 |c_#NULL.base|) .cse312 .cse313 (= c_main_~list~5.offset 0) .cse314 .cse315 .cse316 .cse317 .cse318 .cse319 (= v_weq1_1 .cse304) (= .cse320 v_weq1_1) .cse321 .cse322) (let ((.cse323 (select .cse325 v_weq1_1))) (and .cse302 .cse303 .cse305 .cse306 .cse307 .cse308 .cse310 .cse298 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse309 0) (= .cse304 .cse323) (= .cse311 .cse299) .cse312 (= c_main_~list~5.offset .cse309) .cse313 .cse314 .cse315 .cse316 .cse317 .cse318 .cse319 (= |c_main_#t~malloc0.offset| (select .cse324 v_weq1_1)) (= .cse299 |c_#NULL.base|) (= .cse301 v_weq1_1) (= .cse323 c_main_~end~5.offset) .cse321 .cse322 (= .cse320 .cse304)))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (or (not (= v_weq0_1 |c_main_#t~malloc0.base|)) (and (not (= v_weq1_1 (+ c_main_~list~5.offset 4))) (not (= v_weq1_1 0))) (= (select (select |c_#memory_$Pointer$.base| v_weq0_1) v_weq1_1) (select (select |c_#memory_$Pointer$.offset| v_weq0_1) v_weq1_1)))) (= .cse144 |c_main_#t~malloc0.offset|) (forall ((v_weq0_1 Int)) (let ((.cse339 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse330 (select .cse339 v_weq0_1))) (or (= .cse330 (select |c_#valid| v_weq0_1)) (let ((.cse335 (+ c_main_~list~5.offset 4)) (.cse338 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse333 (select .cse338 v_weq0_1)) (.cse332 (select |c_old(#valid)| 0)) (.cse336 (select .cse339 .cse335)) (.cse334 (select |c_#valid| c_main_~list~5.offset)) (.cse337 (select .cse338 .cse335)) (.cse331 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse331 c_main_~end~5.offset) (= .cse332 .cse333) (= .cse330 |c_#NULL.offset|) (= .cse333 .cse334) (= .cse335 v_weq0_1) (= c_main_~end~5.offset .cse330) (= 0 .cse332) (not (= 0 |c_main_#t~malloc0.base|)) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse336 0) (not (= |c_main_#t~malloc0.base| 0)) (= c_main_~list~5.offset .cse336) (= .cse334 .cse337) (= .cse337 .cse331)))) (not (= v_weq0_1 0)))))) (= .cse245 .cse340) (= .cse340 .cse0) (= 1 (select |c_#valid| |c_main_#t~malloc0.base|)) (not (= |c_#valid| |c_old(#valid)|))))) is different from false [2018-01-21 10:54:07,121 WARN L1007 $PredicateComparison]: unable to prove that (let ((.cse341 (+ c_main_~list~5.offset 4))) (let ((.cse144 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse341)) (.cse244 (select |c_old(#valid)| 0)) (.cse245 (select |c_#valid| c_main_~list~5.offset)) (.cse340 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse341)) (.cse0 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= .cse0 c_main_~end~5.offset) (forall ((v_weq0_1 Int)) (let ((.cse15 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse13 (+ c_main_~list~5.offset 4))) (let ((.cse7 (select |c_#valid| c_main_~list~5.offset)) (.cse8 (select .cse15 .cse13)) (.cse14 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse6 (select |c_old(#valid)| 0)) (.cse5 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (let ((.cse2 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse3 (= .cse5 c_main_~end~5.offset)) (.cse10 (= 0 .cse6)) (.cse4 (not (= 0 |c_main_#t~malloc0.base|))) (.cse1 (select .cse14 .cse13)) (.cse9 (= .cse7 .cse8)) (.cse11 (select .cse15 v_weq0_1))) (or (and (= .cse1 c_main_~list~5.offset) .cse2 .cse3 (= |c_#NULL.base| .cse1) .cse4 (= v_weq0_1 .cse5) (= c_main_~list~5.offset 0) (= .cse6 .cse7) (= c_main_~end~5.offset |c_#NULL.offset|) (= .cse8 v_weq0_1) .cse9 .cse10) (let ((.cse12 (select .cse14 v_weq0_1))) (and .cse2 .cse3 (= .cse6 .cse11) (= .cse12 |c_#NULL.offset|) (= .cse11 .cse7) (= .cse13 v_weq0_1) (= c_main_~end~5.offset .cse12) .cse10 .cse4 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse1 0) (= c_main_~list~5.offset .cse1) .cse9 (= .cse8 .cse5))) (= .cse11 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1))))))) (= c_main_~end~5.offset |c_#NULL.offset|) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse21 (+ c_main_~list~5.offset 4))) (let ((.cse16 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse17 (select |c_old(#valid)| 0)) (.cse19 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse21)) (.cse18 (select |c_#valid| c_main_~list~5.offset)) (.cse20 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse21))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse16 c_main_~end~5.offset) (= v_weq0_1 .cse16) (= c_main_~list~5.offset 0) (= .cse17 .cse18) (= c_main_~end~5.offset |c_#NULL.offset|) (= 0 .cse17) (= .cse19 c_main_~list~5.offset) (= |c_#NULL.base| .cse19) (not (= 0 |c_main_#t~malloc0.base|)) (not (= |c_main_#t~malloc0.base| 0)) (= .cse20 v_weq0_1) (= .cse18 .cse20)))))) (forall ((v_weq0_1 Int)) (let ((.cse30 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse24 (select .cse30 v_weq0_1))) (or (let ((.cse27 (+ c_main_~list~5.offset 4)) (.cse31 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse25 (select .cse31 v_weq0_1)) (.cse23 (select |c_old(#valid)| 0)) (.cse28 (select .cse31 .cse27)) (.cse26 (select |c_#valid| c_main_~list~5.offset)) (.cse29 (select .cse30 .cse27)) (.cse22 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse22 c_main_~end~5.offset) (= .cse23 .cse24) (= .cse25 |c_#NULL.offset|) (= .cse24 .cse26) (= .cse27 v_weq0_1) (= c_main_~end~5.offset .cse25) (= 0 .cse23) (not (= 0 |c_main_#t~malloc0.base|)) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse28 0) (not (= |c_main_#t~malloc0.base| 0)) (= c_main_~list~5.offset .cse28) (= .cse26 .cse29) (= .cse29 .cse22)))) (= .cse24 (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int)) (let ((.cse47 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse33 (+ c_main_~list~5.offset 4))) (let ((.cse38 (select |c_#valid| c_main_~list~5.offset)) (.cse44 (select .cse47 .cse33)) (.cse46 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse36 (select |c_old(#valid)| 0)) (.cse45 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (let ((.cse32 (select .cse47 v_weq0_1)) (.cse34 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse35 (= .cse45 c_main_~end~5.offset)) (.cse39 (= 0 .cse36)) (.cse41 (select .cse46 .cse33)) (.cse40 (not (= 0 |c_main_#t~malloc0.base|))) (.cse42 (not (= |c_main_#t~malloc0.base| 0))) (.cse43 (= .cse38 .cse44))) (or (= .cse32 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 .cse33)) (not (= v_weq0_1 0))) (let ((.cse37 (select .cse46 v_weq0_1))) (and .cse34 .cse35 (= .cse36 .cse32) (= .cse37 |c_#NULL.offset|) (= .cse32 .cse38) (= .cse33 v_weq0_1) (= c_main_~end~5.offset .cse37) .cse39 .cse40 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse41 0) .cse42 (= c_main_~list~5.offset .cse41) .cse43 (= .cse44 .cse45))) (and .cse34 .cse35 (= v_weq0_1 .cse45) (= c_main_~list~5.offset 0) (= .cse36 .cse38) (= c_main_~end~5.offset |c_#NULL.offset|) .cse39 (= .cse41 c_main_~list~5.offset) (= |c_#NULL.base| .cse41) .cse40 .cse42 (= .cse44 v_weq0_1) .cse43)))))) (forall ((v_weq0_1 Int)) (let ((.cse61 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse48 (+ c_main_~list~5.offset 4))) (let ((.cse56 (select |c_#valid| c_main_~list~5.offset)) (.cse57 (select .cse61 .cse48)) (.cse55 (select |c_old(#valid)| 0)) (.cse62 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse54 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (let ((.cse51 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse52 (= .cse54 c_main_~end~5.offset)) (.cse49 (select .cse62 v_weq0_1)) (.cse59 (= 0 .cse55)) (.cse53 (not (= 0 |c_main_#t~malloc0.base|))) (.cse50 (select .cse62 .cse48)) (.cse58 (= .cse56 .cse57))) (or (and (not (= v_weq0_1 .cse48)) (not (= v_weq0_1 0))) (= .cse49 (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1)) (and (= .cse50 c_main_~list~5.offset) .cse51 .cse52 (= |c_#NULL.base| .cse50) .cse53 (= v_weq0_1 .cse54) (= c_main_~list~5.offset 0) (= .cse55 .cse56) (= c_main_~end~5.offset |c_#NULL.offset|) (= .cse57 v_weq0_1) .cse58 .cse59) (let ((.cse60 (select .cse61 v_weq0_1))) (and .cse51 .cse52 (= .cse55 .cse60) (= .cse49 |c_#NULL.offset|) (= .cse60 .cse56) (= .cse48 v_weq0_1) (= c_main_~end~5.offset .cse49) .cse59 .cse53 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse50 0) (= c_main_~list~5.offset .cse50) .cse58 (= .cse57 .cse54)))))))) (forall ((v_weq0_1 Int)) (let ((.cse76 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse75 (+ c_main_~list~5.offset 4))) (let ((.cse69 (select |c_#valid| c_main_~list~5.offset)) (.cse70 (select .cse76 .cse75)) (.cse77 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse68 (select |c_old(#valid)| 0)) (.cse67 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (let ((.cse64 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse65 (= .cse67 c_main_~end~5.offset)) (.cse72 (= 0 .cse68)) (.cse66 (not (= 0 |c_main_#t~malloc0.base|))) (.cse63 (select .cse77 .cse75)) (.cse71 (= .cse69 .cse70)) (.cse74 (select .cse77 v_weq0_1))) (or (and (= .cse63 c_main_~list~5.offset) .cse64 .cse65 (= |c_#NULL.base| .cse63) .cse66 (= v_weq0_1 .cse67) (= c_main_~list~5.offset 0) (= .cse68 .cse69) (= c_main_~end~5.offset |c_#NULL.offset|) (= .cse70 v_weq0_1) .cse71 .cse72) (let ((.cse73 (select .cse76 v_weq0_1))) (and .cse64 .cse65 (= .cse68 .cse73) (= .cse74 |c_#NULL.offset|) (= .cse73 .cse69) (= .cse75 v_weq0_1) (= c_main_~end~5.offset .cse74) .cse72 .cse66 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse63 0) (= c_main_~list~5.offset .cse63) .cse71 (= .cse70 .cse67))) (= .cse74 (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse106 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse100 (+ c_main_~list~5.offset 4))) (let ((.cse103 (select .cse106 .cse100)) (.cse90 (select |c_old(#valid)| v_weq0_1)) (.cse107 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse110 (select |c_#valid| v_weq0_1)) (.cse111 (select |c_old(#valid)| 0)) (.cse109 (select |c_#valid| c_main_~list~5.offset)) (.cse108 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse104 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse105 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse79 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse80 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse82 (= .cse104 .cse105)) (.cse83 (not (= 0 c_main_~end~5.base))) (.cse84 (= c_main_~end~5.offset |c_#NULL.offset|)) (.cse85 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse87 (select .cse104 .cse100)) (.cse86 (= c_main_~list~5.base c_main_~end~5.base)) (.cse78 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse92 (= .cse106 .cse108)) (.cse93 (= .cse111 .cse109)) (.cse94 (= .cse110 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse95 (not (= c_main_~end~5.base 0))) (.cse96 (= .cse107 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse97 (= 0 .cse111)) (.cse98 (= 1 .cse110)) (.cse99 (= (select .cse105 .cse100) .cse90)) (.cse88 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse101 (= .cse109 .cse103)) (.cse102 (= (select |c_#length| v_weq0_1) 8))) (or (not .cse78) (let ((.cse81 (select .cse106 v_weq1_1)) (.cse91 (select .cse105 v_weq1_1)) (.cse89 (select .cse104 v_weq1_1))) (and .cse79 .cse80 (= |c_#NULL.offset| .cse81) .cse82 .cse83 .cse84 .cse85 .cse86 .cse78 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse87 0) (= .cse88 .cse89) (= .cse90 .cse91) .cse92 (= c_main_~list~5.offset .cse87) .cse93 .cse94 .cse95 .cse96 .cse97 .cse98 .cse99 (= .cse81 |c_main_#t~malloc0.offset|) (= .cse91 |c_#NULL.base|) (= .cse100 v_weq1_1) (= .cse89 c_main_~end~5.offset) .cse101 .cse102 (= .cse103 .cse88))) (and (not (= v_weq1_1 .cse100)) (not (= v_weq1_1 0))) (= (select .cse107 v_weq1_1) (select .cse108 v_weq1_1)) (and .cse79 .cse80 (= .cse88 c_main_~end~5.offset) .cse82 .cse83 .cse84 .cse85 (= .cse87 c_main_~list~5.offset) (= |c_#NULL.base| .cse87) .cse86 .cse78 (= .cse90 |c_#NULL.base|) .cse92 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= c_main_~list~5.offset 0) .cse93 .cse94 .cse95 .cse96 .cse97 .cse98 .cse99 (= v_weq1_1 .cse88) (= .cse103 v_weq1_1) .cse101 .cse102)))))) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (not (= 0 |c_main_#t~malloc0.base|)) (= c_main_~list~5.base c_main_~end~5.base) (not (= |c_#valid| |c_#length|)) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse137 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse138 (+ c_main_~list~5.offset 4))) (let ((.cse133 (select .cse137 .cse138)) (.cse124 (select |c_old(#valid)| v_weq0_1)) (.cse112 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse142 (select |c_#valid| v_weq0_1)) (.cse143 (select |c_old(#valid)| 0)) (.cse140 (select |c_#valid| c_main_~list~5.offset)) (.cse139 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse141 (select |c_#memory_$Pointer$.offset| v_weq0_1))) (let ((.cse114 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse115 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (.cse117 (= .cse139 .cse141)) (.cse118 (not (= 0 c_main_~end~5.base))) (.cse119 (= c_main_~end~5.offset |c_#NULL.offset|)) (.cse120 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse122 (= c_main_~list~5.base c_main_~end~5.base)) (.cse123 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse125 (= .cse137 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse121 (select .cse139 .cse138)) (.cse126 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse127 (= .cse143 .cse140)) (.cse128 (= .cse142 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse129 (= .cse112 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse130 (= 0 .cse143)) (.cse131 (= 1 .cse142)) (.cse132 (= (select .cse141 .cse138) .cse124)) (.cse113 (select .cse141 v_weq1_1)) (.cse134 (= .cse140 .cse133)) (.cse135 (= (select |c_#length| v_weq0_1) 8)) (.cse116 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (or (= (select .cse112 v_weq1_1) .cse113) (and .cse114 .cse115 (= .cse116 c_main_~end~5.offset) .cse117 .cse118 .cse119 .cse120 (= .cse121 c_main_~list~5.offset) (= |c_#NULL.base| .cse121) .cse122 .cse123 (= .cse124 |c_#NULL.base|) .cse125 .cse126 (= c_main_~list~5.offset 0) .cse127 .cse128 .cse129 .cse130 .cse131 .cse132 (= v_weq1_1 .cse116) (= .cse133 v_weq1_1) .cse134 .cse135) (let ((.cse136 (select .cse139 v_weq1_1))) (and .cse114 .cse115 .cse117 .cse118 .cse119 .cse120 .cse122 .cse123 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse121 0) (= .cse116 .cse136) (= .cse124 .cse113) .cse125 (= c_main_~list~5.offset .cse121) .cse126 .cse127 .cse128 .cse129 .cse130 .cse131 .cse132 (= |c_main_#t~malloc0.offset| (select .cse137 v_weq1_1)) (= .cse113 |c_#NULL.base|) (= .cse138 v_weq1_1) (= .cse136 c_main_~end~5.offset) .cse134 .cse135 (= .cse133 .cse116)))))))) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse144 0) (= c_main_~list~5.offset .cse144) (forall ((v_weq0_1 Int)) (let ((.cse146 (select |c_#valid| v_weq0_1)) (.cse145 (select |c_old(#valid)| v_weq0_1))) (or (= .cse145 .cse146) (let ((.cse151 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse148 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse154 (+ c_main_~list~5.offset 4))) (let ((.cse150 (select .cse148 .cse154)) (.cse152 (select |c_old(#valid)| 0)) (.cse149 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse153 (select |c_#valid| c_main_~list~5.offset)) (.cse155 (select .cse151 .cse154)) (.cse147 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= .cse147 c_main_~end~5.offset) (= .cse148 .cse149) (not (= 0 c_main_~end~5.base)) (= c_main_~end~5.offset |c_#NULL.offset|) (= |c_main_#t~malloc0.base| c_main_~list~5.base) (= c_main_~list~5.base c_main_~end~5.base) (= v_weq0_1 |c_main_#t~malloc0.base|) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse150 0) (= .cse145 |c_#NULL.base|) (= .cse151 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= c_main_~list~5.offset .cse150) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse152 .cse153) (= .cse146 (select |c_#valid| |c_main_#t~malloc0.base|)) (not (= c_main_~end~5.base 0)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 0 .cse152) (= 1 .cse146) (= (select .cse149 .cse154) .cse145) (= .cse153 .cse155) (= (select |c_#length| v_weq0_1) 8) (= .cse155 .cse147))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse185 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse179 (+ c_main_~list~5.offset 4))) (let ((.cse182 (select .cse185 .cse179)) (.cse170 (select |c_old(#valid)| v_weq0_1)) (.cse187 (select |c_#valid| v_weq0_1)) (.cse188 (select |c_old(#valid)| 0)) (.cse186 (select |c_#valid| c_main_~list~5.offset)) (.cse156 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse183 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse184 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse157 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse158 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse159 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse157)) (.cse161 (= .cse183 .cse184)) (.cse162 (not (= 0 c_main_~end~5.base))) (.cse163 (= c_main_~end~5.offset |c_#NULL.offset|)) (.cse164 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse167 (select .cse183 .cse179)) (.cse165 (= c_main_~list~5.base c_main_~end~5.base)) (.cse166 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse172 (= .cse185 .cse156)) (.cse173 (= .cse188 .cse186)) (.cse174 (= .cse187 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse175 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse176 (= 0 .cse188)) (.cse177 (= 1 .cse187)) (.cse178 (= (select .cse184 .cse179) .cse170)) (.cse168 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse180 (= .cse186 .cse182)) (.cse181 (= (select |c_#length| v_weq0_1) 8))) (or (= (select .cse156 v_weq1_1) (select .cse157 v_weq1_1)) (let ((.cse160 (select .cse185 v_weq1_1)) (.cse171 (select .cse184 v_weq1_1)) (.cse169 (select .cse183 v_weq1_1))) (and .cse158 .cse159 (= |c_#NULL.offset| .cse160) .cse161 .cse162 .cse163 .cse164 .cse165 .cse166 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse167 0) (= .cse168 .cse169) (= .cse170 .cse171) .cse172 (= c_main_~list~5.offset .cse167) .cse173 .cse174 .cse175 .cse176 .cse177 .cse178 (= .cse160 |c_main_#t~malloc0.offset|) (= .cse171 |c_#NULL.base|) (= .cse179 v_weq1_1) (= .cse169 c_main_~end~5.offset) .cse180 .cse181 (= .cse182 .cse168))) (and .cse158 .cse159 (= .cse168 c_main_~end~5.offset) .cse161 .cse162 .cse163 .cse164 (= .cse167 c_main_~list~5.offset) (= |c_#NULL.base| .cse167) .cse165 .cse166 (= .cse170 |c_#NULL.base|) .cse172 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= c_main_~list~5.offset 0) .cse173 .cse174 .cse175 .cse176 .cse177 .cse178 (= v_weq1_1 .cse168) (= .cse182 v_weq1_1) .cse180 .cse181)))))) (not (= |c_#length| |c_old(#valid)|)) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse220 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse214 (+ c_main_~list~5.offset 4))) (let ((.cse218 (select .cse220 .cse214)) (.cse223 (select |c_old(#memory_$Pointer$.offset)| v_weq0_1)) (.cse226 (select |c_#valid| v_weq0_1)) (.cse227 (select |c_old(#valid)| 0)) (.cse225 (select |c_#valid| c_main_~list~5.offset)) (.cse219 (select |c_#memory_$Pointer$.base| v_weq0_1)) (.cse222 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse221 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse224 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse215 (not (= v_weq1_1 0))) (.cse190 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse191 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse224)) (.cse193 (= .cse222 .cse221)) (.cse195 (not (= 0 c_main_~end~5.base))) (.cse196 (= c_main_~end~5.offset |c_#NULL.offset|)) (.cse197 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse199 (select .cse222 .cse214)) (.cse198 (= c_main_~list~5.base c_main_~end~5.base)) (.cse189 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse204 (= .cse220 .cse219)) (.cse208 (= .cse227 .cse225)) (.cse209 (= .cse226 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse210 (not (= c_main_~end~5.base 0))) (.cse211 (= .cse223 (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse212 (= 0 .cse227)) (.cse213 (= 1 .cse226)) (.cse206 (select .cse221 .cse214)) (.cse202 (select |c_old(#valid)| v_weq0_1)) (.cse200 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse216 (= .cse225 .cse218)) (.cse217 (= (select |c_#length| v_weq0_1) 8))) (or (not .cse189) (let ((.cse201 (select .cse222 v_weq1_1)) (.cse203 (select .cse221 v_weq1_1))) (let ((.cse207 (select |c_old(#valid)| .cse203)) (.cse194 (select |c_old(#valid)| .cse201)) (.cse192 (select .cse220 v_weq1_1)) (.cse205 (select .cse219 .cse214))) (and .cse190 .cse191 (= |c_#NULL.offset| .cse192) .cse193 (= |c_#NULL.base| .cse194) .cse195 .cse196 .cse197 .cse198 .cse189 (= .cse199 0) (= .cse200 .cse201) (= .cse202 .cse203) .cse204 (= c_main_~list~5.offset .cse199) (= .cse205 |c_#NULL.base|) (= .cse206 .cse207) .cse208 (= .cse207 .cse202) .cse209 (= .cse194 c_main_~list~5.offset) .cse210 .cse211 .cse212 .cse213 (= .cse192 |c_main_#t~malloc0.offset|) (= .cse214 v_weq1_1) .cse215 (= .cse201 c_main_~end~5.offset) .cse216 (= .cse203 .cse205) .cse217 (= .cse218 .cse200)))) (= (select .cse223 v_weq1_1) (select .cse224 v_weq1_1)) (and (not (= v_weq1_1 .cse214)) .cse215) (and .cse190 .cse191 (= .cse200 c_main_~end~5.offset) .cse193 .cse195 .cse196 .cse197 (= .cse199 c_main_~list~5.offset) (= |c_#NULL.base| .cse199) .cse198 .cse189 (= .cse202 |c_#NULL.base|) .cse204 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= c_main_~list~5.offset 0) .cse208 .cse209 .cse210 .cse211 .cse212 .cse213 (= .cse206 .cse202) (= v_weq1_1 .cse200) (= .cse218 v_weq1_1) .cse216 .cse217)))))) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (forall ((v_weq0_1 Int)) (let ((.cse237 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse231 (select .cse237 v_weq0_1))) (or (let ((.cse233 (+ c_main_~list~5.offset 4)) (.cse236 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse230 (select .cse236 v_weq0_1)) (.cse229 (select |c_old(#valid)| 0)) (.cse234 (select .cse237 .cse233)) (.cse232 (select |c_#valid| c_main_~list~5.offset)) (.cse235 (select .cse236 .cse233)) (.cse228 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse228 c_main_~end~5.offset) (= .cse229 .cse230) (= .cse231 |c_#NULL.offset|) (= .cse230 .cse232) (= .cse233 v_weq0_1) (= c_main_~end~5.offset .cse231) (= 0 .cse229) (not (= 0 |c_main_#t~malloc0.base|)) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse234 0) (not (= |c_main_#t~malloc0.base| 0)) (= c_main_~list~5.offset .cse234) (= .cse232 .cse235) (= .cse235 .cse228)))) (not (= v_weq0_1 0)) (= .cse231 (select |c_old(#valid)| v_weq0_1)))))) (forall ((v_weq0_1 Int)) (or (= (select |c_old(#valid)| v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse243 (+ c_main_~list~5.offset 4))) (let ((.cse238 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse239 (select |c_old(#valid)| 0)) (.cse241 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse243)) (.cse240 (select |c_#valid| c_main_~list~5.offset)) (.cse242 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse243))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse238 c_main_~end~5.offset) (= v_weq0_1 .cse238) (= c_main_~list~5.offset 0) (= .cse239 .cse240) (= c_main_~end~5.offset |c_#NULL.offset|) (= 0 .cse239) (= .cse241 c_main_~list~5.offset) (= |c_#NULL.base| .cse241) (not (= 0 |c_main_#t~malloc0.base|)) (not (= |c_main_#t~malloc0.base| 0)) (= .cse242 v_weq0_1) (= .cse240 .cse242)))))) (= .cse244 .cse245) (forall ((v_weq0_1 Int)) (let ((.cse254 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse246 (select .cse254 v_weq0_1))) (or (= .cse246 (select |c_old(#valid)| v_weq0_1)) (let ((.cse251 (+ c_main_~list~5.offset 4)) (.cse255 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse249 (select .cse255 v_weq0_1)) (.cse248 (select |c_old(#valid)| 0)) (.cse252 (select .cse255 .cse251)) (.cse250 (select |c_#valid| c_main_~list~5.offset)) (.cse253 (select .cse254 .cse251)) (.cse247 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse247 c_main_~end~5.offset) (= .cse248 .cse246) (= .cse249 |c_#NULL.offset|) (= .cse246 .cse250) (= .cse251 v_weq0_1) (= c_main_~end~5.offset .cse249) (= 0 .cse248) (not (= 0 |c_main_#t~malloc0.base|)) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse252 0) (not (= |c_main_#t~malloc0.base| 0)) (= c_main_~list~5.offset .cse252) (= .cse250 .cse253) (= .cse253 .cse247)))) (not (= v_weq0_1 0)))))) (forall ((v_weq0_1 Int)) (let ((.cse267 (select |c_#length| v_weq0_1))) (or (let ((.cse265 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse257 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse262 (+ c_main_~list~5.offset 4))) (let ((.cse259 (select |c_old(#valid)| 0)) (.cse261 (select |c_#valid| v_weq0_1)) (.cse258 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse264 (select .cse257 .cse262)) (.cse263 (select |c_old(#valid)| v_weq0_1)) (.cse260 (select |c_#valid| c_main_~list~5.offset)) (.cse266 (select .cse265 .cse262)) (.cse256 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= 8 (select |c_#length| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) (select |c_old(#memory_$Pointer$.base)| v_weq0_1)) (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= v_weq0_1 c_main_~list~5.base) (= .cse256 c_main_~end~5.offset) (= .cse257 .cse258) (= c_main_~list~5.base |c_main_#t~malloc0.base|) (not (= 0 c_main_~end~5.base)) (= c_main_~list~5.offset 0) (= .cse259 .cse260) (= c_main_~end~5.offset |c_#NULL.offset|) (= |c_main_#t~malloc0.base| c_main_~end~5.base) (= .cse261 (select |c_#valid| |c_main_#t~malloc0.base|)) (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base)) (= 0 .cse259) (= 1 .cse261) (= (select .cse258 .cse262) .cse263) (= .cse264 c_main_~list~5.offset) (= |c_#NULL.base| .cse264) (= .cse263 |c_#NULL.base|) (= .cse265 (select |c_#memory_$Pointer$.base| v_weq0_1)) (= .cse260 .cse266) (= .cse267 8) (= .cse266 .cse256)))) (= .cse267 (select |c_old(#length)| v_weq0_1))))) (= 0 .cse244) (forall ((v_weq0_1 Int)) (or (= (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) v_weq0_1) (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) v_weq0_1)) (and (not (= v_weq0_1 (+ c_main_~list~5.offset 4))) (not (= v_weq0_1 0))))) (forall ((v_weq0_1 Int)) (let ((.cse284 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse275 (+ c_main_~list~5.offset 4))) (let ((.cse274 (select |c_#valid| c_main_~list~5.offset)) (.cse282 (select .cse284 .cse275)) (.cse285 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse271 (select |c_old(#valid)| 0)) (.cse283 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (let ((.cse280 (not (= v_weq0_1 0))) (.cse269 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse270 (= .cse283 c_main_~end~5.offset)) (.cse276 (= 0 .cse271)) (.cse278 (select .cse285 .cse275)) (.cse277 (not (= 0 |c_main_#t~malloc0.base|))) (.cse279 (not (= |c_main_#t~malloc0.base| 0))) (.cse281 (= .cse274 .cse282))) (or (let ((.cse273 (select .cse285 v_weq0_1))) (let ((.cse268 (select |c_old(#valid)| .cse273)) (.cse272 (select .cse284 v_weq0_1))) (and (= .cse268 |c_#NULL.offset|) .cse269 .cse270 (= .cse271 .cse272) (= .cse273 .cse268) (= .cse272 .cse274) (= .cse275 v_weq0_1) (= c_main_~end~5.offset .cse273) .cse276 .cse277 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse278 0) .cse279 .cse280 (= c_main_~list~5.offset .cse278) .cse281 (= .cse282 .cse283)))) (and (not (= v_weq0_1 .cse275)) .cse280) (and .cse269 .cse270 (= v_weq0_1 .cse283) (= c_main_~list~5.offset 0) (= .cse271 .cse274) (= c_main_~end~5.offset |c_#NULL.offset|) .cse276 (= .cse278 c_main_~list~5.offset) (= |c_#NULL.base| .cse278) .cse277 .cse279 (= .cse282 v_weq0_1) .cse281) (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1))))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base) v_weq0_1) (select |c_#valid| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse291 (+ c_main_~list~5.offset 4))) (let ((.cse286 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse287 (select |c_old(#valid)| 0)) (.cse289 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse291)) (.cse288 (select |c_#valid| c_main_~list~5.offset)) (.cse290 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse291))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse286 c_main_~end~5.offset) (= v_weq0_1 .cse286) (= c_main_~list~5.offset 0) (= .cse287 .cse288) (= c_main_~end~5.offset |c_#NULL.offset|) (= 0 .cse287) (= .cse289 c_main_~list~5.offset) (= |c_#NULL.base| .cse289) (not (= 0 |c_main_#t~malloc0.base|)) (not (= |c_main_#t~malloc0.base| 0)) (= .cse290 v_weq0_1) (= .cse288 .cse290)))))) (forall ((v_weq0_1 Int)) (or (= (select (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) v_weq0_1) (select |c_old(#valid)| v_weq0_1)) (not (= v_weq0_1 0)) (let ((.cse297 (+ c_main_~list~5.offset 4))) (let ((.cse292 (select |c_old(#valid)| |c_main_#t~malloc0.base|)) (.cse293 (select |c_old(#valid)| 0)) (.cse295 (select (select |c_#memory_$Pointer$.offset| c_main_~list~5.base) .cse297)) (.cse294 (select |c_#valid| c_main_~list~5.offset)) (.cse296 (select (select |c_#memory_$Pointer$.base| c_main_~list~5.base) .cse297))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse292 c_main_~end~5.offset) (= v_weq0_1 .cse292) (= c_main_~list~5.offset 0) (= .cse293 .cse294) (= c_main_~end~5.offset |c_#NULL.offset|) (= 0 .cse293) (= .cse295 c_main_~list~5.offset) (= |c_#NULL.base| .cse295) (not (= 0 |c_main_#t~malloc0.base|)) (not (= |c_main_#t~malloc0.base| 0)) (= .cse296 v_weq0_1) (= .cse294 .cse296)))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (let ((.cse324 (select |c_#memory_$Pointer$.base| c_main_~list~5.base)) (.cse301 (+ c_main_~list~5.offset 4))) (let ((.cse320 (select .cse324 .cse301)) (.cse311 (select |c_old(#valid)| v_weq0_1)) (.cse328 (select |c_#valid| v_weq0_1)) (.cse329 (select |c_old(#valid)| 0)) (.cse326 (select |c_#valid| c_main_~list~5.offset)) (.cse325 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base)) (.cse327 (select |c_#memory_$Pointer$.offset| v_weq0_1)) (.cse300 (select |c_old(#memory_$Pointer$.base)| v_weq0_1))) (let ((.cse302 (= 8 (select |c_#length| |c_main_#t~malloc0.base|))) (.cse303 (= (select |c_old(#memory_$Pointer$.base)| c_main_~list~5.base) .cse300)) (.cse305 (= .cse325 .cse327)) (.cse306 (not (= 0 c_main_~end~5.base))) (.cse307 (= c_main_~end~5.offset |c_#NULL.offset|)) (.cse308 (= |c_main_#t~malloc0.base| c_main_~list~5.base)) (.cse310 (= c_main_~list~5.base c_main_~end~5.base)) (.cse298 (= v_weq0_1 |c_main_#t~malloc0.base|)) (.cse312 (= .cse324 (select |c_#memory_$Pointer$.base| v_weq0_1))) (.cse309 (select .cse325 .cse301)) (.cse313 (= |c_#NULL.offset| |c_main_#t~malloc0.offset|)) (.cse314 (= .cse329 .cse326)) (.cse315 (= .cse328 (select |c_#valid| |c_main_#t~malloc0.base|))) (.cse316 (= (select |c_old(#memory_$Pointer$.offset)| v_weq0_1) (select |c_old(#memory_$Pointer$.offset)| c_main_~list~5.base))) (.cse317 (= 0 .cse329)) (.cse318 (= 1 .cse328)) (.cse319 (= (select .cse327 .cse301) .cse311)) (.cse299 (select .cse327 v_weq1_1)) (.cse321 (= .cse326 .cse320)) (.cse322 (= (select |c_#length| v_weq0_1) 8)) (.cse304 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (or (not .cse298) (= .cse299 (select .cse300 v_weq1_1)) (and (not (= v_weq1_1 .cse301)) (not (= v_weq1_1 0))) (and .cse302 .cse303 (= .cse304 c_main_~end~5.offset) .cse305 .cse306 .cse307 .cse308 (= .cse309 c_main_~list~5.offset) (= |c_#NULL.base| .cse309) .cse310 .cse298 (= .cse311 |c_#NULL.base|) .cse312 .cse313 (= c_main_~list~5.offset 0) .cse314 .cse315 .cse316 .cse317 .cse318 .cse319 (= v_weq1_1 .cse304) (= .cse320 v_weq1_1) .cse321 .cse322) (let ((.cse323 (select .cse325 v_weq1_1))) (and .cse302 .cse303 .cse305 .cse306 .cse307 .cse308 .cse310 .cse298 (= |c_#NULL.base| c_main_~list~5.offset) (= .cse309 0) (= .cse304 .cse323) (= .cse311 .cse299) .cse312 (= c_main_~list~5.offset .cse309) .cse313 .cse314 .cse315 .cse316 .cse317 .cse318 .cse319 (= |c_main_#t~malloc0.offset| (select .cse324 v_weq1_1)) (= .cse299 |c_#NULL.base|) (= .cse301 v_weq1_1) (= .cse323 c_main_~end~5.offset) .cse321 .cse322 (= .cse320 .cse304)))))))) (forall ((v_weq0_1 Int) (v_weq1_1 Int)) (or (not (= v_weq0_1 |c_main_#t~malloc0.base|)) (and (not (= v_weq1_1 (+ c_main_~list~5.offset 4))) (not (= v_weq1_1 0))) (= (select (select |c_#memory_$Pointer$.base| v_weq0_1) v_weq1_1) (select (select |c_#memory_$Pointer$.offset| v_weq0_1) v_weq1_1)))) (forall ((v_weq0_1 Int)) (let ((.cse339 (select |c_#memory_$Pointer$.offset| c_main_~list~5.base))) (let ((.cse330 (select .cse339 v_weq0_1))) (or (= .cse330 (select |c_#valid| v_weq0_1)) (let ((.cse335 (+ c_main_~list~5.offset 4)) (.cse338 (select |c_#memory_$Pointer$.base| c_main_~list~5.base))) (let ((.cse333 (select .cse338 v_weq0_1)) (.cse332 (select |c_old(#valid)| 0)) (.cse336 (select .cse339 .cse335)) (.cse334 (select |c_#valid| c_main_~list~5.offset)) (.cse337 (select .cse338 .cse335)) (.cse331 (select |c_old(#valid)| |c_main_#t~malloc0.base|))) (and (= |c_#NULL.offset| |c_main_#t~malloc0.offset|) (= .cse331 c_main_~end~5.offset) (= .cse332 .cse333) (= .cse330 |c_#NULL.offset|) (= .cse333 .cse334) (= .cse335 v_weq0_1) (= c_main_~end~5.offset .cse330) (= 0 .cse332) (not (= 0 |c_main_#t~malloc0.base|)) (= |c_#NULL.base| c_main_~list~5.offset) (= .cse336 0) (not (= |c_main_#t~malloc0.base| 0)) (= c_main_~list~5.offset .cse336) (= .cse334 .cse337) (= .cse337 .cse331)))) (not (= v_weq0_1 0)))))) (= .cse245 .cse340) (= .cse340 .cse0) (= 1 (select |c_#valid| |c_main_#t~malloc0.base|)) (not (= |c_#valid| |c_old(#valid)|))))) is different from false [2018-01-21 10:54:07,147 WARN L491 AbstractCegarLoop]: Verification canceled [2018-01-21 10:54:07,149 INFO L202 PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction CFG 21.01 10:54:07 BoogieIcfgContainer [2018-01-21 10:54:07,149 INFO L132 PluginConnector]: ------------------------ END TraceAbstraction---------------------------- [2018-01-21 10:54:07,150 INFO L168 Benchmark]: Toolchain (without parser) took 66464.91 ms. Allocated memory was 309.3 MB in the beginning and 2.3 GB in the end (delta: 2.0 GB). Free memory was 267.3 MB in the beginning and 1.9 GB in the end (delta: -1.6 GB). Peak memory consumption was 373.2 MB. Max. memory is 5.3 GB. [2018-01-21 10:54:07,150 INFO L168 Benchmark]: CDTParser took 0.13 ms. Allocated memory is still 309.3 MB. Free memory is still 273.2 MB. There was no memory consumed. Max. memory is 5.3 GB. [2018-01-21 10:54:07,151 INFO L168 Benchmark]: CACSL2BoogieTranslator took 225.57 ms. Allocated memory is still 309.3 MB. Free memory was 266.3 MB in the beginning and 254.3 MB in the end (delta: 12.0 MB). Peak memory consumption was 12.0 MB. Max. memory is 5.3 GB. [2018-01-21 10:54:07,151 INFO L168 Benchmark]: Boogie Preprocessor took 38.23 ms. Allocated memory is still 309.3 MB. Free memory was 254.3 MB in the beginning and 251.3 MB in the end (delta: 3.0 MB). Peak memory consumption was 3.0 MB. Max. memory is 5.3 GB. [2018-01-21 10:54:07,151 INFO L168 Benchmark]: RCFGBuilder took 494.69 ms. Allocated memory is still 309.3 MB. Free memory was 251.3 MB in the beginning and 219.3 MB in the end (delta: 32.0 MB). Peak memory consumption was 32.0 MB. Max. memory is 5.3 GB. [2018-01-21 10:54:07,151 INFO L168 Benchmark]: TraceAbstraction took 65699.10 ms. Allocated memory was 309.3 MB in the beginning and 2.3 GB in the end (delta: 2.0 GB). Free memory was 218.3 MB in the beginning and 1.9 GB in the end (delta: -1.7 GB). Peak memory consumption was 324.3 MB. Max. memory is 5.3 GB. [2018-01-21 10:54:07,153 INFO L344 ainManager$Toolchain]: ####################### End [Toolchain 1] ####################### --- Results --- * Results from de.uni_freiburg.informatik.ultimate.core: - StatisticsResult: Toolchain Benchmarks Benchmark results are: * CDTParser took 0.13 ms. Allocated memory is still 309.3 MB. Free memory is still 273.2 MB. There was no memory consumed. Max. memory is 5.3 GB. * CACSL2BoogieTranslator took 225.57 ms. Allocated memory is still 309.3 MB. Free memory was 266.3 MB in the beginning and 254.3 MB in the end (delta: 12.0 MB). Peak memory consumption was 12.0 MB. Max. memory is 5.3 GB. * Boogie Preprocessor took 38.23 ms. Allocated memory is still 309.3 MB. Free memory was 254.3 MB in the beginning and 251.3 MB in the end (delta: 3.0 MB). Peak memory consumption was 3.0 MB. Max. memory is 5.3 GB. * RCFGBuilder took 494.69 ms. Allocated memory is still 309.3 MB. Free memory was 251.3 MB in the beginning and 219.3 MB in the end (delta: 32.0 MB). Peak memory consumption was 32.0 MB. Max. memory is 5.3 GB. * TraceAbstraction took 65699.10 ms. Allocated memory was 309.3 MB in the beginning and 2.3 GB in the end (delta: 2.0 GB). Free memory was 218.3 MB in the beginning and 1.9 GB in the end (delta: -1.7 GB). Peak memory consumption was 324.3 MB. Max. memory is 5.3 GB. * Results from de.uni_freiburg.informatik.ultimate.plugins.analysis.abstractinterpretationv2: - StatisticsResult: ArrayEqualityDomainStatistics #Locations : 51 LocStat_MAX_WEQGRAPH_SIZE : 22 LocStat_MAX_SIZEOF_WEQEDGELABEL : 6 LocStat_NO_SUPPORTING_EQUALITIES : 746 LocStat_NO_SUPPORTING_DISEQUALITIES : 182 LocStat_NO_DISJUNCTIONS : -102 LocStat_MAX_NO_DISJUNCTIONS : -1 #Transitions : 58 TransStat_MAX_WEQGRAPH_SIZE : 12 TransStat_MAX_SIZEOF_WEQEDGELABEL : 3 TransStat_NO_SUPPORTING_EQUALITIES : 92 TransStat_NO_SUPPORTING_DISEQUALITIES : 20 TransStat_NO_DISJUNCTIONS : 69 TransStat_MAX_NO_DISJUNCTIONS : 4 - StatisticsResult: EqConstraintFactoryStatistics CONJOIN_DISJUNCTIVE(MILLISECONDS) : 0.840183 RENAME_VARIABLES(MILLISECONDS) : 23.569568 UNFREEZE(MILLISECONDS) : 0.000000 CONJOIN(MILLISECONDS) : 0.794003 PROJECTAWAY(MILLISECONDS) : 0.019487 ADD_WEAK_EQUALITY(MILLISECONDS) : 0.077652 DISJOIN(MILLISECONDS) : 29.820169 RENAME_VARIABLES_DISJUNCTIVE(MILLISECONDS) : 23.629869 ADD_EQUALITY(MILLISECONDS) : 0.025455 DISJOIN_DISJUNCTIVE(MILLISECONDS) : 0.000000 ADD_DISEQUALITY(MILLISECONDS) : 0.009772 #CONJOIN_DISJUNCTIVE : 100 #RENAME_VARIABLES : 154 #UNFREEZE : 0 #CONJOIN : 165 #PROJECTAWAY : 131 #ADD_WEAK_EQUALITY : 12 #DISJOIN : 4 #RENAME_VARIABLES_DISJUNCTIVE : 139 #ADD_EQUALITY : 85 #DISJOIN_DISJUNCTIVE : 0 #ADD_DISEQUALITY : 16 * Results from de.uni_freiburg.informatik.ultimate.boogie.preprocessor: - GenericResult: Unfinished Backtranslation Generated EnsuresSpecification ensures #valid == old(#valid); is not ensure(true) - GenericResult: Unfinished Backtranslation Generated EnsuresSpecification ensures #valid == old(#valid); is not ensure(true) - GenericResult: Unfinished Backtranslation Generated EnsuresSpecification ensures #valid == old(#valid); is not ensure(true) - GenericResult: Unfinished Backtranslation Generated EnsuresSpecification ensures #valid == old(#valid); is not ensure(true) * Results from de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction: - CounterExampleResult [Line: 1]: not all allocated memory was freed not all allocated memory was freed We found a FailurePath: - StatisticsResult: Ultimate Automizer benchmark data for error location: ULTIMATE.initErr0EnsuresViolation CFG has 3 procedures, 123 locations, 3 error locations. UNSAFE Result, 0.1s OverallTime, 1 OverallIterations, 1 TraceHistogramMax, 0.0s AutomataDifference, 0.0s DeadEndRemovalTime, 0.0s HoareAnnotationTime, HoareTripleCheckerStatistics: No data available, PredicateUnifierStatistics: No data available, 0.0s BasicInterpolantAutomatonTime, BiggestAbstraction: size=123occurred in iteration=0, traceCheckStatistics: No data available, InterpolantConsolidationStatistics: No data available, PathInvariantsStatistics: No data available, 0/0 InterpolantCoveringCapability, TotalInterpolationStatistics: No data available, 0.0s AbstIntTime, 0 AbstIntIterations, 0 AbstIntStrong, NaN AbsIntWeakeningRatio, NaN AbsIntAvgWeakeningVarsNumRemoved, NaN AbsIntAvgWeakenedConjuncts, AutomataMinimizationStatistics: No data available, HoareAnnotationStatistics: No data available, RefinementEngineStatistics: TraceCheckStatistics: 0.0s SsaConstructionTime, 0.0s SatisfiabilityAnalysisTime, 0.0s InterpolantComputationTime, 3 NumberOfCodeBlocks, 3 NumberOfCodeBlocksAsserted, 1 NumberOfCheckSat, 0 ConstructedInterpolants, 0 QuantifiedInterpolants, 0 SizeOfPredicates, 0 NumberOfNonLiveVariables, 0 ConjunctsInSsa, 0 ConjunctsInUnsatCore, 0 InterpolantComputations, 0 PerfectInterpolantSequences, 0/0 InterpolantCoveringCapability, InvariantSynthesisStatistics: No data available, InterpolantConsolidationStatistics: No data available, REUSE_STATISTICS: No data available - CounterExampleResult [Line: 1]: not all allocated memory was freed not all allocated memory was freed We found a FailurePath: [L991] EXPR, FCALL malloc(sizeof(SLL)) VAL [malloc(sizeof(SLL))={10:0}] [L991] SLL* list = malloc(sizeof(SLL)); VAL [list={10:0}, malloc(sizeof(SLL))={10:0}] [L992] FCALL list->next = ((void*)0) VAL [list={10:0}, malloc(sizeof(SLL))={10:0}] [L993] COND FALSE !(!(list != ((void*)0))) VAL [list={10:0}, malloc(sizeof(SLL))={10:0}] [L993] COND FALSE !(0) VAL [list={10:0}, malloc(sizeof(SLL))={10:0}] [L993] COND TRUE __VERIFIER_nondet_int() [L993] FCALL list->inner = ((void*)0) VAL [list={10:0}, malloc(sizeof(SLL))={10:0}] [L993] EXPR, FCALL list->inner VAL [list={10:0}, list->inner={0:0}, malloc(sizeof(SLL))={10:0}] [L993] EXPR list->inner != ((void*)0) || list->inner == ((void*)0) VAL [list={10:0}, list->inner={0:0}, list->inner != ((void*)0) || list->inner == ((void*)0)=0, malloc(sizeof(SLL))={10:0}] [L993] EXPR, FCALL list->inner VAL [list={10:0}, list->inner={0:0}, list->inner={0:0}, list->inner != ((void*)0) || list->inner == ((void*)0)=0, malloc(sizeof(SLL))={10:0}] [L993] EXPR list->inner != ((void*)0) || list->inner == ((void*)0) VAL [list={10:0}, list->inner={0:0}, list->inner={0:0}, list->inner != ((void*)0) || list->inner == ((void*)0)=1, malloc(sizeof(SLL))={10:0}] [L993] COND FALSE !(!(list->inner != ((void*)0) || list->inner == ((void*)0))) [L993] COND FALSE !(0) VAL [list={10:0}, malloc(sizeof(SLL))={10:0}] [L995] SLL* end = list; VAL [end={10:0}, list={10:0}, malloc(sizeof(SLL))={10:0}] [L998] COND FALSE !(__VERIFIER_nondet_int()) [L1008] end = ((void*)0) [L1009] end = list VAL [end={10:0}, list={10:0}, malloc(sizeof(SLL))={10:0}] [L1012] COND FALSE !(!(((void*)0) != end)) VAL [end={10:0}, list={10:0}, malloc(sizeof(SLL))={10:0}] [L1012] COND FALSE !(0) VAL [end={10:0}, list={10:0}, malloc(sizeof(SLL))={10:0}] [L1014] COND TRUE ((void*)0) != end [L1016] int len = 0; VAL [end={10:0}, len=0, list={10:0}, malloc(sizeof(SLL))={10:0}] [L1017] EXPR, FCALL end->inner VAL [end={10:0}, end->inner={0:0}, len=0, list={10:0}, malloc(sizeof(SLL))={10:0}] [L1017] SLL* inner = end->inner; [L1018] COND FALSE !(((void*)0) != inner) VAL [end={10:0}, inner={0:0}, len=0, list={10:0}, malloc(sizeof(SLL))={10:0}] [L1029] COND FALSE !(!(len <= 1)) VAL [end={10:0}, inner={0:0}, len=0, list={10:0}, malloc(sizeof(SLL))={10:0}] [L1029] COND FALSE !(0) VAL [end={10:0}, inner={0:0}, len=0, list={10:0}, malloc(sizeof(SLL))={10:0}] [L1031] EXPR, FCALL end->next VAL [end={10:0}, end->next={0:0}, inner={0:0}, len=0, list={10:0}, malloc(sizeof(SLL))={10:0}] [L1031] end = end->next [L1014] COND FALSE !(((void*)0) != end) VAL [end={0:0}, inner={0:0}, len=0, list={10:0}, malloc(sizeof(SLL))={10:0}] [L1035] COND TRUE ((void*)0) != list VAL [end={0:0}, inner={0:0}, len=0, list={10:0}, malloc(sizeof(SLL))={10:0}] [L1037] EXPR, FCALL list->inner VAL [end={0:0}, inner={0:0}, len=0, list={10:0}, list->inner={0:0}, malloc(sizeof(SLL))={10:0}] [L1037] end = list->inner [L1039] COND FALSE !(((void*)0) != end) VAL [end={0:0}, inner={0:0}, len=0, list={10:0}, malloc(sizeof(SLL))={10:0}] [L1047] EXPR, FCALL list->next VAL [end={0:0}, inner={0:0}, len=0, list={10:0}, list->next={0:0}, malloc(sizeof(SLL))={10:0}] [L1047] end = list->next [L1048] FCALL free(list) VAL [end={0:0}, inner={0:0}, len=0, list={10:0}, malloc(sizeof(SLL))={10:0}] [L1049] list = end VAL [end={0:0}, inner={0:0}, len=0, list={0:0}, malloc(sizeof(SLL))={10:0}] [L1035] COND FALSE !(((void*)0) != list) VAL [end={0:0}, inner={0:0}, len=0, list={0:0}, malloc(sizeof(SLL))={10:0}] [L1052] return 0; - StatisticsResult: Ultimate Automizer benchmark data for error location: ULTIMATE.startErr0EnsuresViolation CFG has 3 procedures, 123 locations, 3 error locations. UNSAFE Result, 1.0s OverallTime, 4 OverallIterations, 2 TraceHistogramMax, 0.5s AutomataDifference, 0.0s DeadEndRemovalTime, 0.0s HoareAnnotationTime, HoareTripleCheckerStatistics: 350 SDtfs, 417 SDslu, 428 SDs, 0 SdLazy, 161 SolverSat, 5 SolverUnsat, 0 SolverUnknown, 0 SolverNotchecked, 0.2s Time, PredicateUnifierStatistics: 0 DeclaredPredicates, 16 GetRequests, 6 SyntacticMatches, 0 SemanticMatches, 10 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.1s Time, 0.0s BasicInterpolantAutomatonTime, BiggestAbstraction: size=128occurred in iteration=3, traceCheckStatistics: No data available, InterpolantConsolidationStatistics: No data available, PathInvariantsStatistics: No data available, 0/0 InterpolantCoveringCapability, TotalInterpolationStatistics: No data available, 0.0s AbstIntTime, 0 AbstIntIterations, 0 AbstIntStrong, NaN AbsIntWeakeningRatio, NaN AbsIntAvgWeakeningVarsNumRemoved, NaN AbsIntAvgWeakenedConjuncts, AutomataMinimizationStatistics: 0.0s AutomataMinimizationTime, 3 MinimizatonAttempts, 115 StatesRemovedByMinimization, 2 NontrivialMinimizations, HoareAnnotationStatistics: No data available, RefinementEngineStatistics: TraceCheckStatistics: 0.0s SsaConstructionTime, 0.0s SatisfiabilityAnalysisTime, 0.2s InterpolantComputationTime, 155 NumberOfCodeBlocks, 155 NumberOfCodeBlocksAsserted, 4 NumberOfCheckSat, 94 ConstructedInterpolants, 0 QuantifiedInterpolants, 7469 SizeOfPredicates, 0 NumberOfNonLiveVariables, 0 ConjunctsInSsa, 0 ConjunctsInUnsatCore, 3 InterpolantComputations, 3 PerfectInterpolantSequences, 0/0 InterpolantCoveringCapability, InvariantSynthesisStatistics: No data available, InterpolantConsolidationStatistics: No data available, REUSE_STATISTICS: No data available - TimeoutResultAtElement [Line: 988]: Timeout (TraceAbstraction) Unable to prove that all allocated memory was freed (line 988). Cancelled while BasicCegarLoop was analyzing trace of length 57 with TraceHistMax 2, while AbsIntCurrentIteration was generating AI predicates, while PredicateComparison was comparing new predicate (quantified with 0quantifier alternations) to 20 known predicates. - StatisticsResult: Ultimate Automizer benchmark data for error location: mainErr0EnsuresViolation CFG has 3 procedures, 123 locations, 3 error locations. TIMEOUT Result, 64.4s OverallTime, 4 OverallIterations, 2 TraceHistogramMax, 0.2s AutomataDifference, 0.0s DeadEndRemovalTime, 0.0s HoareAnnotationTime, HoareTripleCheckerStatistics: 346 SDtfs, 417 SDslu, 417 SDs, 0 SdLazy, 160 SolverSat, 5 SolverUnsat, 0 SolverUnknown, 0 SolverNotchecked, 0.1s Time, PredicateUnifierStatistics: 0 DeclaredPredicates, 16 GetRequests, 6 SyntacticMatches, 0 SemanticMatches, 10 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.1s Time, 0.0s BasicInterpolantAutomatonTime, BiggestAbstraction: size=126occurred in iteration=3, traceCheckStatistics: No data available, InterpolantConsolidationStatistics: No data available, PathInvariantsStatistics: No data available, 0/0 InterpolantCoveringCapability, TotalInterpolationStatistics: No data available, 18.3s AbstIntTime, 1 AbstIntIterations, 1 AbstIntStrong, 0.9529280085239836 AbsIntWeakeningRatio, 0.7272727272727273 AbsIntAvgWeakeningVarsNumRemoved, 18.70909090909091 AbsIntAvgWeakenedConjuncts, AutomataMinimizationStatistics: 0.0s AutomataMinimizationTime, 3 MinimizatonAttempts, 115 StatesRemovedByMinimization, 2 NontrivialMinimizations, HoareAnnotationStatistics: No data available, RefinementEngineStatistics: TraceCheckStatistics: 0.0s SsaConstructionTime, 0.0s SatisfiabilityAnalysisTime, 0.1s InterpolantComputationTime, 91 NumberOfCodeBlocks, 91 NumberOfCodeBlocksAsserted, 3 NumberOfCheckSat, 88 ConstructedInterpolants, 0 QuantifiedInterpolants, 6863 SizeOfPredicates, 0 NumberOfNonLiveVariables, 0 ConjunctsInSsa, 0 ConjunctsInUnsatCore, 3 InterpolantComputations, 3 PerfectInterpolantSequences, 0/0 InterpolantCoveringCapability, InvariantSynthesisStatistics: No data available, InterpolantConsolidationStatistics: No data available, REUSE_STATISTICS: No data available RESULT: Ultimate proved your program to be incorrect! Written .csv to /storage/ultimate/releaseScripts/default/UAutomizer-linux/../../../releaseScripts/default/UAutomizer-linux/csv/sll-01_true-unreach-call_true-valid-memsafety.i_mempurity-32bit-Automizer_Taipan+AI_EQ_smtcomp.epf_AutomizerC.xml/Csv-Benchmark-0-2018-01-21_10-54-07-161.csv Written .csv to /storage/ultimate/releaseScripts/default/UAutomizer-linux/../../../releaseScripts/default/UAutomizer-linux/csv/sll-01_true-unreach-call_true-valid-memsafety.i_mempurity-32bit-Automizer_Taipan+AI_EQ_smtcomp.epf_AutomizerC.xml/Csv-VPDomainBenchmark-0-2018-01-21_10-54-07-161.csv Written .csv to /storage/ultimate/releaseScripts/default/UAutomizer-linux/../../../releaseScripts/default/UAutomizer-linux/csv/sll-01_true-unreach-call_true-valid-memsafety.i_mempurity-32bit-Automizer_Taipan+AI_EQ_smtcomp.epf_AutomizerC.xml/Csv-BenchmarkWithCounters-0-2018-01-21_10-54-07-161.csv Written .csv to /storage/ultimate/releaseScripts/default/UAutomizer-linux/../../../releaseScripts/default/UAutomizer-linux/csv/sll-01_true-unreach-call_true-valid-memsafety.i_mempurity-32bit-Automizer_Taipan+AI_EQ_smtcomp.epf_AutomizerC.xml/Csv-TraceAbstractionBenchmarks-0-2018-01-21_10-54-07-161.csv Written .csv to /storage/ultimate/releaseScripts/default/UAutomizer-linux/../../../releaseScripts/default/UAutomizer-linux/csv/sll-01_true-unreach-call_true-valid-memsafety.i_mempurity-32bit-Automizer_Taipan+AI_EQ_smtcomp.epf_AutomizerC.xml/Csv-TraceAbstractionBenchmarks-1-2018-01-21_10-54-07-161.csv Written .csv to /storage/ultimate/releaseScripts/default/UAutomizer-linux/../../../releaseScripts/default/UAutomizer-linux/csv/sll-01_true-unreach-call_true-valid-memsafety.i_mempurity-32bit-Automizer_Taipan+AI_EQ_smtcomp.epf_AutomizerC.xml/Csv-TraceAbstractionBenchmarks-2-2018-01-21_10-54-07-161.csv Completed graceful shutdown