java -ea -Xmx8000000000 -jar /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/plugins/org.eclipse.equinox.launcher_1.3.100.v20150511-1540.jar -data @noDefault -ultimatedata /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data -tc ../../../trunk/examples/toolchains/AutomizerCInline_WitnessPrinter.xml -s ../../../trunk/examples/settings/default/automizer/svcomp-Reach-32bit-Automizer_Bitvector.epf -i ../../../trunk/examples/svcomp/loop-invgen/SpamAssassin-loop_true-unreach-call_false-termination.i -------------------------------------------------------------------------------- This is Ultimate 0.1.23-61f4311 [2018-11-23 11:32:26,102 INFO L170 SettingsManager]: Resetting all preferences to default values... [2018-11-23 11:32:26,104 INFO L174 SettingsManager]: Resetting UltimateCore preferences to default values [2018-11-23 11:32:26,117 INFO L177 SettingsManager]: Ultimate Commandline Interface provides no preferences, ignoring... [2018-11-23 11:32:26,117 INFO L174 SettingsManager]: Resetting Boogie Preprocessor preferences to default values [2018-11-23 11:32:26,118 INFO L174 SettingsManager]: Resetting Boogie Procedure Inliner preferences to default values [2018-11-23 11:32:26,120 INFO L174 SettingsManager]: Resetting Abstract Interpretation preferences to default values [2018-11-23 11:32:26,122 INFO L174 SettingsManager]: Resetting LassoRanker preferences to default values [2018-11-23 11:32:26,124 INFO L174 SettingsManager]: Resetting Reaching Definitions preferences to default values [2018-11-23 11:32:26,125 INFO L174 SettingsManager]: Resetting SyntaxChecker preferences to default values [2018-11-23 11:32:26,126 INFO L177 SettingsManager]: Büchi Program Product provides no preferences, ignoring... [2018-11-23 11:32:26,127 INFO L174 SettingsManager]: Resetting LTL2Aut preferences to default values [2018-11-23 11:32:26,128 INFO L174 SettingsManager]: Resetting PEA to Boogie preferences to default values [2018-11-23 11:32:26,129 INFO L174 SettingsManager]: Resetting BlockEncodingV2 preferences to default values [2018-11-23 11:32:26,130 INFO L174 SettingsManager]: Resetting ChcToBoogie preferences to default values [2018-11-23 11:32:26,133 INFO L174 SettingsManager]: Resetting AutomataScriptInterpreter preferences to default values [2018-11-23 11:32:26,134 INFO L174 SettingsManager]: Resetting BuchiAutomizer preferences to default values [2018-11-23 11:32:26,139 INFO L174 SettingsManager]: Resetting CACSL2BoogieTranslator preferences to default values [2018-11-23 11:32:26,148 INFO L174 SettingsManager]: Resetting CodeCheck preferences to default values [2018-11-23 11:32:26,150 INFO L174 SettingsManager]: Resetting InvariantSynthesis preferences to default values [2018-11-23 11:32:26,152 INFO L174 SettingsManager]: Resetting RCFGBuilder preferences to default values [2018-11-23 11:32:26,159 INFO L174 SettingsManager]: Resetting TraceAbstraction preferences to default values [2018-11-23 11:32:26,162 INFO L177 SettingsManager]: TraceAbstractionConcurrent provides no preferences, ignoring... [2018-11-23 11:32:26,162 INFO L177 SettingsManager]: TraceAbstractionWithAFAs provides no preferences, ignoring... [2018-11-23 11:32:26,165 INFO L174 SettingsManager]: Resetting TreeAutomizer preferences to default values [2018-11-23 11:32:26,166 INFO L174 SettingsManager]: Resetting IcfgTransformer preferences to default values [2018-11-23 11:32:26,167 INFO L174 SettingsManager]: Resetting Boogie Printer preferences to default values [2018-11-23 11:32:26,171 INFO L174 SettingsManager]: Resetting ReqPrinter preferences to default values [2018-11-23 11:32:26,172 INFO L174 SettingsManager]: Resetting Witness Printer preferences to default values [2018-11-23 11:32:26,173 INFO L177 SettingsManager]: Boogie PL CUP Parser provides no preferences, ignoring... [2018-11-23 11:32:26,173 INFO L174 SettingsManager]: Resetting CDTParser preferences to default values [2018-11-23 11:32:26,174 INFO L177 SettingsManager]: AutomataScriptParser provides no preferences, ignoring... [2018-11-23 11:32:26,174 INFO L177 SettingsManager]: ReqParser provides no preferences, ignoring... [2018-11-23 11:32:26,174 INFO L174 SettingsManager]: Resetting SmtParser preferences to default values [2018-11-23 11:32:26,175 INFO L174 SettingsManager]: Resetting Witness Parser preferences to default values [2018-11-23 11:32:26,176 INFO L181 SettingsManager]: Finished resetting all preferences to default values... [2018-11-23 11:32:26,176 INFO L98 SettingsManager]: Beginning loading settings from /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/../../../trunk/examples/settings/default/automizer/svcomp-Reach-32bit-Automizer_Bitvector.epf [2018-11-23 11:32:26,206 INFO L110 SettingsManager]: Loading preferences was successful [2018-11-23 11:32:26,206 INFO L112 SettingsManager]: Preferences different from defaults after loading the file: [2018-11-23 11:32:26,208 INFO L131 SettingsManager]: Preferences of Boogie Procedure Inliner differ from their defaults: [2018-11-23 11:32:26,208 INFO L133 SettingsManager]: * ... calls to implemented procedures=ONLY_FOR_CONCURRENT_PROGRAMS [2018-11-23 11:32:26,209 INFO L131 SettingsManager]: Preferences of BlockEncodingV2 differ from their defaults: [2018-11-23 11:32:26,209 INFO L133 SettingsManager]: * Create parallel compositions if possible=false [2018-11-23 11:32:26,209 INFO L133 SettingsManager]: * Use SBE=true [2018-11-23 11:32:26,210 INFO L131 SettingsManager]: Preferences of CACSL2BoogieTranslator differ from their defaults: [2018-11-23 11:32:26,210 INFO L133 SettingsManager]: * sizeof long=4 [2018-11-23 11:32:26,210 INFO L133 SettingsManager]: * sizeof POINTER=4 [2018-11-23 11:32:26,210 INFO L133 SettingsManager]: * Check division by zero=IGNORE [2018-11-23 11:32:26,210 INFO L133 SettingsManager]: * Pointer to allocated memory at dereference=IGNORE [2018-11-23 11:32:26,210 INFO L133 SettingsManager]: * If two pointers are subtracted or compared they have the same base address=IGNORE [2018-11-23 11:32:26,211 INFO L133 SettingsManager]: * Check array bounds for arrays that are off heap=IGNORE [2018-11-23 11:32:26,211 INFO L133 SettingsManager]: * Use bitvectors instead of ints=true [2018-11-23 11:32:26,211 INFO L133 SettingsManager]: * Memory model=HoenickeLindenmann_4ByteResolution [2018-11-23 11:32:26,211 INFO L133 SettingsManager]: * sizeof long double=12 [2018-11-23 11:32:26,211 INFO L133 SettingsManager]: * Check if freed pointer was valid=false [2018-11-23 11:32:26,213 INFO L133 SettingsManager]: * Use constant arrays=true [2018-11-23 11:32:26,213 INFO L133 SettingsManager]: * Pointer base address is valid at dereference=IGNORE [2018-11-23 11:32:26,213 INFO L131 SettingsManager]: Preferences of RCFGBuilder differ from their defaults: [2018-11-23 11:32:26,214 INFO L133 SettingsManager]: * Size of a code block=SequenceOfStatements [2018-11-23 11:32:26,214 INFO L133 SettingsManager]: * To the following directory=./dump/ [2018-11-23 11:32:26,214 INFO L133 SettingsManager]: * SMT solver=External_DefaultMode [2018-11-23 11:32:26,214 INFO L133 SettingsManager]: * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in -t:2000 [2018-11-23 11:32:26,215 INFO L131 SettingsManager]: Preferences of TraceAbstraction differ from their defaults: [2018-11-23 11:32:26,215 INFO L133 SettingsManager]: * Compute Interpolants along a Counterexample=FPandBP [2018-11-23 11:32:26,215 INFO L133 SettingsManager]: * Positions where we compute the Hoare Annotation=LoopsAndPotentialCycles [2018-11-23 11:32:26,215 INFO L133 SettingsManager]: * Trace refinement strategy=WOLF [2018-11-23 11:32:26,215 INFO L133 SettingsManager]: * SMT solver=External_ModelsAndUnsatCoreMode [2018-11-23 11:32:26,215 INFO L133 SettingsManager]: * Command for external solver=cvc4nyu --tear-down-incremental --rewrite-divk --print-success --lang smt [2018-11-23 11:32:26,216 INFO L133 SettingsManager]: * Logic for external solver=AUFBV [2018-11-23 11:32:26,216 INFO L133 SettingsManager]: * Compute Hoare Annotation of negated interpolant automaton, abstraction and CFG=true [2018-11-23 11:32:26,283 INFO L81 nceAwareModelManager]: Repository-Root is: /tmp [2018-11-23 11:32:26,304 INFO L258 ainManager$Toolchain]: [Toolchain 1]: Applicable parser(s) successfully (re)initialized [2018-11-23 11:32:26,308 INFO L214 ainManager$Toolchain]: [Toolchain 1]: Toolchain selected. [2018-11-23 11:32:26,310 INFO L271 PluginConnector]: Initializing CDTParser... [2018-11-23 11:32:26,310 INFO L276 PluginConnector]: CDTParser initialized [2018-11-23 11:32:26,311 INFO L418 ainManager$Toolchain]: [Toolchain 1]: Parsing single file: /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/../../../trunk/examples/svcomp/loop-invgen/SpamAssassin-loop_true-unreach-call_false-termination.i [2018-11-23 11:32:26,379 INFO L221 CDTParser]: Created temporary CDT project at /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/1f289b57c/2f96f05cd56341f7a11e39352b411622/FLAG27c3a7d77 [2018-11-23 11:32:26,799 INFO L307 CDTParser]: Found 1 translation units. [2018-11-23 11:32:26,800 INFO L161 CDTParser]: Scanning /storage/repos/ultimate/trunk/examples/svcomp/loop-invgen/SpamAssassin-loop_true-unreach-call_false-termination.i [2018-11-23 11:32:26,807 INFO L355 CDTParser]: About to delete temporary CDT project at /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/1f289b57c/2f96f05cd56341f7a11e39352b411622/FLAG27c3a7d77 [2018-11-23 11:32:27,171 INFO L363 CDTParser]: Successfully deleted /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/1f289b57c/2f96f05cd56341f7a11e39352b411622 [2018-11-23 11:32:27,181 INFO L296 ainManager$Toolchain]: ####################### [Toolchain 1] ####################### [2018-11-23 11:32:27,183 INFO L131 ToolchainWalker]: Walking toolchain with 6 elements. [2018-11-23 11:32:27,184 INFO L113 PluginConnector]: ------------------------CACSL2BoogieTranslator---------------------------- [2018-11-23 11:32:27,184 INFO L271 PluginConnector]: Initializing CACSL2BoogieTranslator... [2018-11-23 11:32:27,188 INFO L276 PluginConnector]: CACSL2BoogieTranslator initialized [2018-11-23 11:32:27,189 INFO L185 PluginConnector]: Executing the observer ACSLObjectContainerObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 23.11 11:32:27" (1/1) ... [2018-11-23 11:32:27,193 INFO L205 PluginConnector]: Invalid model from CACSL2BoogieTranslator for observer de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator.ACSLObjectContainerObserver@6b8176b8 and model type de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 11:32:27, skipping insertion in model container [2018-11-23 11:32:27,193 INFO L185 PluginConnector]: Executing the observer CACSL2BoogieTranslatorObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 23.11 11:32:27" (1/1) ... [2018-11-23 11:32:27,203 INFO L145 MainTranslator]: Starting translation in SV-COMP mode [2018-11-23 11:32:27,231 INFO L176 MainTranslator]: Built tables and reachable declarations [2018-11-23 11:32:27,495 INFO L201 PostProcessor]: Analyzing one entry point: main [2018-11-23 11:32:27,500 INFO L191 MainTranslator]: Completed pre-run [2018-11-23 11:32:27,533 INFO L201 PostProcessor]: Analyzing one entry point: main [2018-11-23 11:32:27,552 INFO L195 MainTranslator]: Completed translation [2018-11-23 11:32:27,553 INFO L202 PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 11:32:27 WrapperNode [2018-11-23 11:32:27,553 INFO L132 PluginConnector]: ------------------------ END CACSL2BoogieTranslator---------------------------- [2018-11-23 11:32:27,554 INFO L113 PluginConnector]: ------------------------Boogie Procedure Inliner---------------------------- [2018-11-23 11:32:27,554 INFO L271 PluginConnector]: Initializing Boogie Procedure Inliner... [2018-11-23 11:32:27,554 INFO L276 PluginConnector]: Boogie Procedure Inliner initialized [2018-11-23 11:32:27,563 INFO L185 PluginConnector]: Executing the observer TypeChecker from plugin Boogie Procedure Inliner for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 11:32:27" (1/1) ... [2018-11-23 11:32:27,571 INFO L185 PluginConnector]: Executing the observer Inliner from plugin Boogie Procedure Inliner for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 11:32:27" (1/1) ... [2018-11-23 11:32:27,578 INFO L132 PluginConnector]: ------------------------ END Boogie Procedure Inliner---------------------------- [2018-11-23 11:32:27,578 INFO L113 PluginConnector]: ------------------------Boogie Preprocessor---------------------------- [2018-11-23 11:32:27,579 INFO L271 PluginConnector]: Initializing Boogie Preprocessor... [2018-11-23 11:32:27,579 INFO L276 PluginConnector]: Boogie Preprocessor initialized [2018-11-23 11:32:27,588 INFO L185 PluginConnector]: Executing the observer EnsureBoogieModelObserver from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 11:32:27" (1/1) ... [2018-11-23 11:32:27,588 INFO L185 PluginConnector]: Executing the observer TypeChecker from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 11:32:27" (1/1) ... [2018-11-23 11:32:27,590 INFO L185 PluginConnector]: Executing the observer ConstExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 11:32:27" (1/1) ... [2018-11-23 11:32:27,590 INFO L185 PluginConnector]: Executing the observer StructExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 11:32:27" (1/1) ... [2018-11-23 11:32:27,601 INFO L185 PluginConnector]: Executing the observer UnstructureCode from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 11:32:27" (1/1) ... [2018-11-23 11:32:27,611 INFO L185 PluginConnector]: Executing the observer FunctionInliner from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 11:32:27" (1/1) ... [2018-11-23 11:32:27,613 INFO L185 PluginConnector]: Executing the observer BoogieSymbolTableConstructor from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 11:32:27" (1/1) ... [2018-11-23 11:32:27,615 INFO L132 PluginConnector]: ------------------------ END Boogie Preprocessor---------------------------- [2018-11-23 11:32:27,616 INFO L113 PluginConnector]: ------------------------RCFGBuilder---------------------------- [2018-11-23 11:32:27,616 INFO L271 PluginConnector]: Initializing RCFGBuilder... [2018-11-23 11:32:27,616 INFO L276 PluginConnector]: RCFGBuilder initialized [2018-11-23 11:32:27,617 INFO L185 PluginConnector]: Executing the observer RCFGBuilderObserver from plugin RCFGBuilder for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 11:32:27" (1/1) ... No working directory specified, using /storage/repos/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-11-23 11:32:27,745 INFO L130 BoogieDeclarations]: Found specification of procedure ULTIMATE.init [2018-11-23 11:32:27,745 INFO L138 BoogieDeclarations]: Found implementation of procedure ULTIMATE.init [2018-11-23 11:32:27,746 INFO L130 BoogieDeclarations]: Found specification of procedure ULTIMATE.start [2018-11-23 11:32:27,746 INFO L138 BoogieDeclarations]: Found implementation of procedure ULTIMATE.start [2018-11-23 11:32:27,746 INFO L130 BoogieDeclarations]: Found specification of procedure main [2018-11-23 11:32:27,746 INFO L138 BoogieDeclarations]: Found implementation of procedure main [2018-11-23 11:32:27,746 INFO L130 BoogieDeclarations]: Found specification of procedure __VERIFIER_assert [2018-11-23 11:32:27,746 INFO L138 BoogieDeclarations]: Found implementation of procedure __VERIFIER_assert [2018-11-23 11:32:28,513 INFO L275 CfgBuilder]: Using the 1 location(s) as analysis (start of procedure ULTIMATE.start) [2018-11-23 11:32:28,513 INFO L280 CfgBuilder]: Removed 2 assue(true) statements. [2018-11-23 11:32:28,513 INFO L202 PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 23.11 11:32:28 BoogieIcfgContainer [2018-11-23 11:32:28,514 INFO L132 PluginConnector]: ------------------------ END RCFGBuilder---------------------------- [2018-11-23 11:32:28,515 INFO L113 PluginConnector]: ------------------------TraceAbstraction---------------------------- [2018-11-23 11:32:28,515 INFO L271 PluginConnector]: Initializing TraceAbstraction... [2018-11-23 11:32:28,519 INFO L276 PluginConnector]: TraceAbstraction initialized [2018-11-23 11:32:28,519 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "CDTParser AST 23.11 11:32:27" (1/3) ... [2018-11-23 11:32:28,520 INFO L205 PluginConnector]: Invalid model from TraceAbstraction for observer de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionObserver@3ee6caa2 and model type de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction AST 23.11 11:32:28, skipping insertion in model container [2018-11-23 11:32:28,520 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 11:32:27" (2/3) ... [2018-11-23 11:32:28,521 INFO L205 PluginConnector]: Invalid model from TraceAbstraction for observer de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionObserver@3ee6caa2 and model type de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction AST 23.11 11:32:28, skipping insertion in model container [2018-11-23 11:32:28,521 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 23.11 11:32:28" (3/3) ... [2018-11-23 11:32:28,523 INFO L112 eAbstractionObserver]: Analyzing ICFG SpamAssassin-loop_true-unreach-call_false-termination.i [2018-11-23 11:32:28,533 INFO L156 ceAbstractionStarter]: Automizer settings: Hoare:true NWA Interpolation:FPandBP Determinization: PREDICATE_ABSTRACTION [2018-11-23 11:32:28,540 INFO L168 ceAbstractionStarter]: Appying trace abstraction to program that has 1 error locations. [2018-11-23 11:32:28,558 INFO L257 AbstractCegarLoop]: Starting to check reachability of 1 error locations. [2018-11-23 11:32:28,593 INFO L133 ementStrategyFactory]: Using default assertion order modulation [2018-11-23 11:32:28,594 INFO L382 AbstractCegarLoop]: Interprodecural is true [2018-11-23 11:32:28,594 INFO L383 AbstractCegarLoop]: Hoare is true [2018-11-23 11:32:28,594 INFO L384 AbstractCegarLoop]: Compute interpolants for FPandBP [2018-11-23 11:32:28,596 INFO L385 AbstractCegarLoop]: Backedges is STRAIGHT_LINE [2018-11-23 11:32:28,596 INFO L386 AbstractCegarLoop]: Determinization is PREDICATE_ABSTRACTION [2018-11-23 11:32:28,596 INFO L387 AbstractCegarLoop]: Difference is false [2018-11-23 11:32:28,597 INFO L388 AbstractCegarLoop]: Minimize is MINIMIZE_SEVPA [2018-11-23 11:32:28,597 INFO L393 AbstractCegarLoop]: ======== Iteration 0==of CEGAR loop == AllErrorsAtOnce======== [2018-11-23 11:32:28,618 INFO L276 IsEmpty]: Start isEmpty. Operand 41 states. [2018-11-23 11:32:28,623 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 14 [2018-11-23 11:32:28,624 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 11:32:28,625 INFO L402 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 11:32:28,627 INFO L423 AbstractCegarLoop]: === Iteration 1 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 11:32:28,632 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 11:32:28,632 INFO L82 PathProgramCache]: Analyzing trace with hash -230433750, now seen corresponding path program 1 times [2018-11-23 11:32:28,636 INFO L223 ckRefinementStrategy]: Switched to mode CVC4_FPBP [2018-11-23 11:32:28,636 INFO L69 tionRefinementEngine]: Using refinement strategy WolfRefinementStrategy No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/cvc4nyu Starting monitored process 2 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 2 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk [2018-11-23 11:32:28,659 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 11:32:28,690 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:28,713 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:28,718 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 11:32:29,139 INFO L256 TraceCheckUtils]: 0: Hoare triple {44#true} call ULTIMATE.init(); {44#true} is VALID [2018-11-23 11:32:29,144 INFO L273 TraceCheckUtils]: 1: Hoare triple {44#true} assume true; {44#true} is VALID [2018-11-23 11:32:29,145 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {44#true} {44#true} #77#return; {44#true} is VALID [2018-11-23 11:32:29,146 INFO L256 TraceCheckUtils]: 3: Hoare triple {44#true} call #t~ret11 := main(); {44#true} is VALID [2018-11-23 11:32:29,146 INFO L273 TraceCheckUtils]: 4: Hoare triple {44#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {44#true} is VALID [2018-11-23 11:32:29,147 INFO L273 TraceCheckUtils]: 5: Hoare triple {44#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {44#true} is VALID [2018-11-23 11:32:29,161 INFO L273 TraceCheckUtils]: 6: Hoare triple {44#true} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {67#(bvslt main_~i~0 main_~len~0)} is VALID [2018-11-23 11:32:29,163 INFO L273 TraceCheckUtils]: 7: Hoare triple {67#(bvslt main_~i~0 main_~len~0)} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {67#(bvslt main_~i~0 main_~len~0)} is VALID [2018-11-23 11:32:29,165 INFO L273 TraceCheckUtils]: 8: Hoare triple {67#(bvslt main_~i~0 main_~len~0)} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {67#(bvslt main_~i~0 main_~len~0)} is VALID [2018-11-23 11:32:29,166 INFO L256 TraceCheckUtils]: 9: Hoare triple {67#(bvslt main_~i~0 main_~len~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {77#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:29,168 INFO L273 TraceCheckUtils]: 10: Hoare triple {77#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} ~cond := #in~cond; {81#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:29,168 INFO L273 TraceCheckUtils]: 11: Hoare triple {81#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} assume 0bv32 == ~cond; {45#false} is VALID [2018-11-23 11:32:29,169 INFO L273 TraceCheckUtils]: 12: Hoare triple {45#false} assume !false; {45#false} is VALID [2018-11-23 11:32:29,173 INFO L134 CoverageAnalysis]: Checked inductivity of 0 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 11:32:29,173 INFO L312 TraceCheckSpWp]: Omiting computation of backward sequence because forward sequence was already perfect [2018-11-23 11:32:29,177 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 11:32:29,178 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [5] imperfect sequences [] total 5 [2018-11-23 11:32:29,183 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 13 [2018-11-23 11:32:29,186 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 11:32:29,190 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states. [2018-11-23 11:32:29,248 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 13 edges. 13 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:29,248 INFO L459 AbstractCegarLoop]: Interpolant automaton has 5 states [2018-11-23 11:32:29,258 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 5 interpolants. [2018-11-23 11:32:29,258 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=7, Invalid=13, Unknown=0, NotChecked=0, Total=20 [2018-11-23 11:32:29,261 INFO L87 Difference]: Start difference. First operand 41 states. Second operand 5 states. [2018-11-23 11:32:30,792 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:30,793 INFO L93 Difference]: Finished difference Result 82 states and 145 transitions. [2018-11-23 11:32:30,793 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 5 states. [2018-11-23 11:32:30,793 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 13 [2018-11-23 11:32:30,794 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 11:32:30,795 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 11:32:30,814 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 145 transitions. [2018-11-23 11:32:30,814 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 11:32:30,830 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 145 transitions. [2018-11-23 11:32:30,830 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states and 145 transitions. [2018-11-23 11:32:31,265 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 145 edges. 145 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:31,281 INFO L225 Difference]: With dead ends: 82 [2018-11-23 11:32:31,281 INFO L226 Difference]: Without dead ends: 42 [2018-11-23 11:32:31,286 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 13 GetRequests, 9 SyntacticMatches, 0 SemanticMatches, 4 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=11, Invalid=19, Unknown=0, NotChecked=0, Total=30 [2018-11-23 11:32:31,306 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 42 states. [2018-11-23 11:32:31,359 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 42 to 40. [2018-11-23 11:32:31,359 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 11:32:31,360 INFO L82 GeneralOperation]: Start isEquivalent. First operand 42 states. Second operand 40 states. [2018-11-23 11:32:31,360 INFO L74 IsIncluded]: Start isIncluded. First operand 42 states. Second operand 40 states. [2018-11-23 11:32:31,360 INFO L87 Difference]: Start difference. First operand 42 states. Second operand 40 states. [2018-11-23 11:32:31,370 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:31,370 INFO L93 Difference]: Finished difference Result 42 states and 60 transitions. [2018-11-23 11:32:31,370 INFO L276 IsEmpty]: Start isEmpty. Operand 42 states and 60 transitions. [2018-11-23 11:32:31,372 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:31,372 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:31,373 INFO L74 IsIncluded]: Start isIncluded. First operand 40 states. Second operand 42 states. [2018-11-23 11:32:31,373 INFO L87 Difference]: Start difference. First operand 40 states. Second operand 42 states. [2018-11-23 11:32:31,379 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:31,380 INFO L93 Difference]: Finished difference Result 42 states and 60 transitions. [2018-11-23 11:32:31,380 INFO L276 IsEmpty]: Start isEmpty. Operand 42 states and 60 transitions. [2018-11-23 11:32:31,382 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:31,382 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:31,382 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 11:32:31,383 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 11:32:31,383 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 40 states. [2018-11-23 11:32:31,388 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 40 states to 40 states and 57 transitions. [2018-11-23 11:32:31,390 INFO L78 Accepts]: Start accepts. Automaton has 40 states and 57 transitions. Word has length 13 [2018-11-23 11:32:31,390 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 11:32:31,390 INFO L480 AbstractCegarLoop]: Abstraction has 40 states and 57 transitions. [2018-11-23 11:32:31,390 INFO L481 AbstractCegarLoop]: Interpolant automaton has 5 states. [2018-11-23 11:32:31,391 INFO L276 IsEmpty]: Start isEmpty. Operand 40 states and 57 transitions. [2018-11-23 11:32:31,391 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 14 [2018-11-23 11:32:31,392 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 11:32:31,392 INFO L402 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 11:32:31,392 INFO L423 AbstractCegarLoop]: === Iteration 2 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 11:32:31,393 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 11:32:31,393 INFO L82 PathProgramCache]: Analyzing trace with hash -251466196, now seen corresponding path program 1 times [2018-11-23 11:32:31,393 INFO L223 ckRefinementStrategy]: Switched to mode CVC4_FPBP [2018-11-23 11:32:31,393 INFO L69 tionRefinementEngine]: Using refinement strategy WolfRefinementStrategy No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/cvc4nyu Starting monitored process 3 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 3 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk [2018-11-23 11:32:31,422 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 11:32:31,433 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:31,456 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:31,458 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 11:32:31,754 INFO L256 TraceCheckUtils]: 0: Hoare triple {364#true} call ULTIMATE.init(); {364#true} is VALID [2018-11-23 11:32:31,755 INFO L273 TraceCheckUtils]: 1: Hoare triple {364#true} assume true; {364#true} is VALID [2018-11-23 11:32:31,756 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {364#true} {364#true} #77#return; {364#true} is VALID [2018-11-23 11:32:31,756 INFO L256 TraceCheckUtils]: 3: Hoare triple {364#true} call #t~ret11 := main(); {364#true} is VALID [2018-11-23 11:32:31,756 INFO L273 TraceCheckUtils]: 4: Hoare triple {364#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {364#true} is VALID [2018-11-23 11:32:31,756 INFO L273 TraceCheckUtils]: 5: Hoare triple {364#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {364#true} is VALID [2018-11-23 11:32:31,757 INFO L273 TraceCheckUtils]: 6: Hoare triple {364#true} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {364#true} is VALID [2018-11-23 11:32:31,757 INFO L273 TraceCheckUtils]: 7: Hoare triple {364#true} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {364#true} is VALID [2018-11-23 11:32:31,776 INFO L273 TraceCheckUtils]: 8: Hoare triple {364#true} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {393#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} is VALID [2018-11-23 11:32:31,785 INFO L256 TraceCheckUtils]: 9: Hoare triple {393#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {397#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:31,787 INFO L273 TraceCheckUtils]: 10: Hoare triple {397#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} ~cond := #in~cond; {401#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:31,787 INFO L273 TraceCheckUtils]: 11: Hoare triple {401#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} assume 0bv32 == ~cond; {365#false} is VALID [2018-11-23 11:32:31,788 INFO L273 TraceCheckUtils]: 12: Hoare triple {365#false} assume !false; {365#false} is VALID [2018-11-23 11:32:31,789 INFO L134 CoverageAnalysis]: Checked inductivity of 0 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 11:32:31,789 INFO L312 TraceCheckSpWp]: Omiting computation of backward sequence because forward sequence was already perfect [2018-11-23 11:32:31,792 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 11:32:31,793 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [5] imperfect sequences [] total 5 [2018-11-23 11:32:31,794 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 13 [2018-11-23 11:32:31,794 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 11:32:31,795 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states. [2018-11-23 11:32:31,818 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 13 edges. 13 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:31,819 INFO L459 AbstractCegarLoop]: Interpolant automaton has 5 states [2018-11-23 11:32:31,819 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 5 interpolants. [2018-11-23 11:32:31,820 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=7, Invalid=13, Unknown=0, NotChecked=0, Total=20 [2018-11-23 11:32:31,820 INFO L87 Difference]: Start difference. First operand 40 states and 57 transitions. Second operand 5 states. [2018-11-23 11:32:32,588 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:32,588 INFO L93 Difference]: Finished difference Result 51 states and 71 transitions. [2018-11-23 11:32:32,588 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 5 states. [2018-11-23 11:32:32,589 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 13 [2018-11-23 11:32:32,589 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 11:32:32,589 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 11:32:32,593 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 68 transitions. [2018-11-23 11:32:32,593 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 11:32:32,597 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 68 transitions. [2018-11-23 11:32:32,597 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states and 68 transitions. [2018-11-23 11:32:32,756 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 68 edges. 68 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:32,760 INFO L225 Difference]: With dead ends: 51 [2018-11-23 11:32:32,760 INFO L226 Difference]: Without dead ends: 49 [2018-11-23 11:32:32,761 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 13 GetRequests, 9 SyntacticMatches, 0 SemanticMatches, 4 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=11, Invalid=19, Unknown=0, NotChecked=0, Total=30 [2018-11-23 11:32:32,762 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 49 states. [2018-11-23 11:32:32,823 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 49 to 44. [2018-11-23 11:32:32,823 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 11:32:32,823 INFO L82 GeneralOperation]: Start isEquivalent. First operand 49 states. Second operand 44 states. [2018-11-23 11:32:32,824 INFO L74 IsIncluded]: Start isIncluded. First operand 49 states. Second operand 44 states. [2018-11-23 11:32:32,824 INFO L87 Difference]: Start difference. First operand 49 states. Second operand 44 states. [2018-11-23 11:32:32,830 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:32,830 INFO L93 Difference]: Finished difference Result 49 states and 69 transitions. [2018-11-23 11:32:32,830 INFO L276 IsEmpty]: Start isEmpty. Operand 49 states and 69 transitions. [2018-11-23 11:32:32,832 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:32,832 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:32,833 INFO L74 IsIncluded]: Start isIncluded. First operand 44 states. Second operand 49 states. [2018-11-23 11:32:32,833 INFO L87 Difference]: Start difference. First operand 44 states. Second operand 49 states. [2018-11-23 11:32:32,838 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:32,839 INFO L93 Difference]: Finished difference Result 49 states and 69 transitions. [2018-11-23 11:32:32,839 INFO L276 IsEmpty]: Start isEmpty. Operand 49 states and 69 transitions. [2018-11-23 11:32:32,841 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:32,841 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:32,841 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 11:32:32,841 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 11:32:32,842 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 44 states. [2018-11-23 11:32:32,845 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 44 states to 44 states and 60 transitions. [2018-11-23 11:32:32,846 INFO L78 Accepts]: Start accepts. Automaton has 44 states and 60 transitions. Word has length 13 [2018-11-23 11:32:32,846 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 11:32:32,846 INFO L480 AbstractCegarLoop]: Abstraction has 44 states and 60 transitions. [2018-11-23 11:32:32,846 INFO L481 AbstractCegarLoop]: Interpolant automaton has 5 states. [2018-11-23 11:32:32,846 INFO L276 IsEmpty]: Start isEmpty. Operand 44 states and 60 transitions. [2018-11-23 11:32:32,847 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 19 [2018-11-23 11:32:32,847 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 11:32:32,847 INFO L402 BasicCegarLoop]: trace histogram [2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 11:32:32,848 INFO L423 AbstractCegarLoop]: === Iteration 3 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 11:32:32,848 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 11:32:32,848 INFO L82 PathProgramCache]: Analyzing trace with hash -932093640, now seen corresponding path program 1 times [2018-11-23 11:32:32,849 INFO L223 ckRefinementStrategy]: Switched to mode CVC4_FPBP [2018-11-23 11:32:32,849 INFO L69 tionRefinementEngine]: Using refinement strategy WolfRefinementStrategy No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/cvc4nyu Starting monitored process 4 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 4 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk [2018-11-23 11:32:32,874 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 11:32:32,891 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:32,899 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:32,900 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 11:32:32,986 INFO L256 TraceCheckUtils]: 0: Hoare triple {656#true} call ULTIMATE.init(); {656#true} is VALID [2018-11-23 11:32:32,987 INFO L273 TraceCheckUtils]: 1: Hoare triple {656#true} assume true; {656#true} is VALID [2018-11-23 11:32:32,987 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {656#true} {656#true} #77#return; {656#true} is VALID [2018-11-23 11:32:32,988 INFO L256 TraceCheckUtils]: 3: Hoare triple {656#true} call #t~ret11 := main(); {656#true} is VALID [2018-11-23 11:32:32,989 INFO L273 TraceCheckUtils]: 4: Hoare triple {656#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {656#true} is VALID [2018-11-23 11:32:32,991 INFO L273 TraceCheckUtils]: 5: Hoare triple {656#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {676#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:32:32,991 INFO L273 TraceCheckUtils]: 6: Hoare triple {676#(= main_~i~0 (_ bv0 32))} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {676#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:32:32,993 INFO L273 TraceCheckUtils]: 7: Hoare triple {676#(= main_~i~0 (_ bv0 32))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {676#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:32:32,993 INFO L273 TraceCheckUtils]: 8: Hoare triple {676#(= main_~i~0 (_ bv0 32))} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {676#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:32:32,993 INFO L256 TraceCheckUtils]: 9: Hoare triple {676#(= main_~i~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {656#true} is VALID [2018-11-23 11:32:32,994 INFO L273 TraceCheckUtils]: 10: Hoare triple {656#true} ~cond := #in~cond; {656#true} is VALID [2018-11-23 11:32:32,994 INFO L273 TraceCheckUtils]: 11: Hoare triple {656#true} assume !(0bv32 == ~cond); {656#true} is VALID [2018-11-23 11:32:32,995 INFO L273 TraceCheckUtils]: 12: Hoare triple {656#true} assume true; {656#true} is VALID [2018-11-23 11:32:32,996 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {656#true} {676#(= main_~i~0 (_ bv0 32))} #105#return; {676#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:32:32,998 INFO L256 TraceCheckUtils]: 14: Hoare triple {676#(= main_~i~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {704#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:32,998 INFO L273 TraceCheckUtils]: 15: Hoare triple {704#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} ~cond := #in~cond; {708#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:33,000 INFO L273 TraceCheckUtils]: 16: Hoare triple {708#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} assume 0bv32 == ~cond; {657#false} is VALID [2018-11-23 11:32:33,000 INFO L273 TraceCheckUtils]: 17: Hoare triple {657#false} assume !false; {657#false} is VALID [2018-11-23 11:32:33,002 INFO L134 CoverageAnalysis]: Checked inductivity of 2 backedges. 2 proven. 0 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 11:32:33,003 INFO L312 TraceCheckSpWp]: Omiting computation of backward sequence because forward sequence was already perfect [2018-11-23 11:32:33,004 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 11:32:33,004 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [5] imperfect sequences [] total 5 [2018-11-23 11:32:33,005 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 18 [2018-11-23 11:32:33,005 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 11:32:33,006 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states. [2018-11-23 11:32:33,037 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 18 edges. 18 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:33,037 INFO L459 AbstractCegarLoop]: Interpolant automaton has 5 states [2018-11-23 11:32:33,037 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 5 interpolants. [2018-11-23 11:32:33,038 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=7, Invalid=13, Unknown=0, NotChecked=0, Total=20 [2018-11-23 11:32:33,038 INFO L87 Difference]: Start difference. First operand 44 states and 60 transitions. Second operand 5 states. [2018-11-23 11:32:33,843 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:33,843 INFO L93 Difference]: Finished difference Result 66 states and 94 transitions. [2018-11-23 11:32:33,843 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 5 states. [2018-11-23 11:32:33,843 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 18 [2018-11-23 11:32:33,844 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 11:32:33,844 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 11:32:33,847 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 88 transitions. [2018-11-23 11:32:33,848 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 11:32:33,851 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 88 transitions. [2018-11-23 11:32:33,851 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states and 88 transitions. [2018-11-23 11:32:33,999 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 88 edges. 88 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:34,003 INFO L225 Difference]: With dead ends: 66 [2018-11-23 11:32:34,003 INFO L226 Difference]: Without dead ends: 64 [2018-11-23 11:32:34,004 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 18 GetRequests, 14 SyntacticMatches, 0 SemanticMatches, 4 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=11, Invalid=19, Unknown=0, NotChecked=0, Total=30 [2018-11-23 11:32:34,004 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 64 states. [2018-11-23 11:32:34,081 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 64 to 58. [2018-11-23 11:32:34,081 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 11:32:34,081 INFO L82 GeneralOperation]: Start isEquivalent. First operand 64 states. Second operand 58 states. [2018-11-23 11:32:34,082 INFO L74 IsIncluded]: Start isIncluded. First operand 64 states. Second operand 58 states. [2018-11-23 11:32:34,082 INFO L87 Difference]: Start difference. First operand 64 states. Second operand 58 states. [2018-11-23 11:32:34,088 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:34,089 INFO L93 Difference]: Finished difference Result 64 states and 92 transitions. [2018-11-23 11:32:34,089 INFO L276 IsEmpty]: Start isEmpty. Operand 64 states and 92 transitions. [2018-11-23 11:32:34,090 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:34,090 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:34,091 INFO L74 IsIncluded]: Start isIncluded. First operand 58 states. Second operand 64 states. [2018-11-23 11:32:34,091 INFO L87 Difference]: Start difference. First operand 58 states. Second operand 64 states. [2018-11-23 11:32:34,097 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:34,097 INFO L93 Difference]: Finished difference Result 64 states and 92 transitions. [2018-11-23 11:32:34,097 INFO L276 IsEmpty]: Start isEmpty. Operand 64 states and 92 transitions. [2018-11-23 11:32:34,099 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:34,099 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:34,099 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 11:32:34,099 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 11:32:34,099 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 58 states. [2018-11-23 11:32:34,104 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 58 states to 58 states and 82 transitions. [2018-11-23 11:32:34,104 INFO L78 Accepts]: Start accepts. Automaton has 58 states and 82 transitions. Word has length 18 [2018-11-23 11:32:34,105 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 11:32:34,105 INFO L480 AbstractCegarLoop]: Abstraction has 58 states and 82 transitions. [2018-11-23 11:32:34,105 INFO L481 AbstractCegarLoop]: Interpolant automaton has 5 states. [2018-11-23 11:32:34,105 INFO L276 IsEmpty]: Start isEmpty. Operand 58 states and 82 transitions. [2018-11-23 11:32:34,106 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 24 [2018-11-23 11:32:34,106 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 11:32:34,107 INFO L402 BasicCegarLoop]: trace histogram [3, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 11:32:34,107 INFO L423 AbstractCegarLoop]: === Iteration 4 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 11:32:34,107 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 11:32:34,107 INFO L82 PathProgramCache]: Analyzing trace with hash -756028246, now seen corresponding path program 1 times [2018-11-23 11:32:34,108 INFO L223 ckRefinementStrategy]: Switched to mode CVC4_FPBP [2018-11-23 11:32:34,108 INFO L69 tionRefinementEngine]: Using refinement strategy WolfRefinementStrategy No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/cvc4nyu Starting monitored process 5 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 5 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk [2018-11-23 11:32:34,135 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 11:32:34,162 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:34,185 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:34,186 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 11:32:34,343 INFO L256 TraceCheckUtils]: 0: Hoare triple {1040#true} call ULTIMATE.init(); {1040#true} is VALID [2018-11-23 11:32:34,343 INFO L273 TraceCheckUtils]: 1: Hoare triple {1040#true} assume true; {1040#true} is VALID [2018-11-23 11:32:34,344 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {1040#true} {1040#true} #77#return; {1040#true} is VALID [2018-11-23 11:32:34,344 INFO L256 TraceCheckUtils]: 3: Hoare triple {1040#true} call #t~ret11 := main(); {1040#true} is VALID [2018-11-23 11:32:34,344 INFO L273 TraceCheckUtils]: 4: Hoare triple {1040#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {1040#true} is VALID [2018-11-23 11:32:34,345 INFO L273 TraceCheckUtils]: 5: Hoare triple {1040#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {1060#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} is VALID [2018-11-23 11:32:34,346 INFO L273 TraceCheckUtils]: 6: Hoare triple {1060#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {1064#(and (= main_~j~0 (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} is VALID [2018-11-23 11:32:34,351 INFO L273 TraceCheckUtils]: 7: Hoare triple {1064#(and (= main_~j~0 (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {1068#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:34,351 INFO L273 TraceCheckUtils]: 8: Hoare triple {1068#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {1068#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:34,352 INFO L256 TraceCheckUtils]: 9: Hoare triple {1068#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {1040#true} is VALID [2018-11-23 11:32:34,352 INFO L273 TraceCheckUtils]: 10: Hoare triple {1040#true} ~cond := #in~cond; {1040#true} is VALID [2018-11-23 11:32:34,352 INFO L273 TraceCheckUtils]: 11: Hoare triple {1040#true} assume !(0bv32 == ~cond); {1040#true} is VALID [2018-11-23 11:32:34,353 INFO L273 TraceCheckUtils]: 12: Hoare triple {1040#true} assume true; {1040#true} is VALID [2018-11-23 11:32:34,354 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {1040#true} {1068#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #105#return; {1068#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:34,354 INFO L256 TraceCheckUtils]: 14: Hoare triple {1068#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {1040#true} is VALID [2018-11-23 11:32:34,354 INFO L273 TraceCheckUtils]: 15: Hoare triple {1040#true} ~cond := #in~cond; {1040#true} is VALID [2018-11-23 11:32:34,355 INFO L273 TraceCheckUtils]: 16: Hoare triple {1040#true} assume !(0bv32 == ~cond); {1040#true} is VALID [2018-11-23 11:32:34,355 INFO L273 TraceCheckUtils]: 17: Hoare triple {1040#true} assume true; {1040#true} is VALID [2018-11-23 11:32:34,360 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {1040#true} {1068#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #107#return; {1068#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:34,362 INFO L256 TraceCheckUtils]: 19: Hoare triple {1068#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {1105#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:34,363 INFO L273 TraceCheckUtils]: 20: Hoare triple {1105#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} ~cond := #in~cond; {1109#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:34,367 INFO L273 TraceCheckUtils]: 21: Hoare triple {1109#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} assume 0bv32 == ~cond; {1041#false} is VALID [2018-11-23 11:32:34,367 INFO L273 TraceCheckUtils]: 22: Hoare triple {1041#false} assume !false; {1041#false} is VALID [2018-11-23 11:32:34,369 INFO L134 CoverageAnalysis]: Checked inductivity of 8 backedges. 4 proven. 0 refuted. 0 times theorem prover too weak. 4 trivial. 0 not checked. [2018-11-23 11:32:34,369 INFO L312 TraceCheckSpWp]: Omiting computation of backward sequence because forward sequence was already perfect [2018-11-23 11:32:34,371 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 11:32:34,371 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [7] imperfect sequences [] total 7 [2018-11-23 11:32:34,371 INFO L78 Accepts]: Start accepts. Automaton has 7 states. Word has length 23 [2018-11-23 11:32:34,371 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 11:32:34,372 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 7 states. [2018-11-23 11:32:34,409 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 20 edges. 20 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:34,409 INFO L459 AbstractCegarLoop]: Interpolant automaton has 7 states [2018-11-23 11:32:34,409 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 7 interpolants. [2018-11-23 11:32:34,409 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=12, Invalid=30, Unknown=0, NotChecked=0, Total=42 [2018-11-23 11:32:34,410 INFO L87 Difference]: Start difference. First operand 58 states and 82 transitions. Second operand 7 states. [2018-11-23 11:32:36,032 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:36,033 INFO L93 Difference]: Finished difference Result 81 states and 117 transitions. [2018-11-23 11:32:36,033 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 7 states. [2018-11-23 11:32:36,033 INFO L78 Accepts]: Start accepts. Automaton has 7 states. Word has length 23 [2018-11-23 11:32:36,033 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 11:32:36,034 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 7 states. [2018-11-23 11:32:36,038 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 7 states to 7 states and 88 transitions. [2018-11-23 11:32:36,039 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 7 states. [2018-11-23 11:32:36,043 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 7 states to 7 states and 88 transitions. [2018-11-23 11:32:36,043 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 7 states and 88 transitions. [2018-11-23 11:32:36,282 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 88 edges. 88 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:36,287 INFO L225 Difference]: With dead ends: 81 [2018-11-23 11:32:36,287 INFO L226 Difference]: Without dead ends: 79 [2018-11-23 11:32:36,288 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 24 GetRequests, 17 SyntacticMatches, 0 SemanticMatches, 7 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 5 ImplicationChecksByTransitivity, 0.1s TimeCoverageRelationStatistics Valid=21, Invalid=51, Unknown=0, NotChecked=0, Total=72 [2018-11-23 11:32:36,288 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 79 states. [2018-11-23 11:32:36,472 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 79 to 75. [2018-11-23 11:32:36,472 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 11:32:36,472 INFO L82 GeneralOperation]: Start isEquivalent. First operand 79 states. Second operand 75 states. [2018-11-23 11:32:36,472 INFO L74 IsIncluded]: Start isIncluded. First operand 79 states. Second operand 75 states. [2018-11-23 11:32:36,473 INFO L87 Difference]: Start difference. First operand 79 states. Second operand 75 states. [2018-11-23 11:32:36,480 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:36,480 INFO L93 Difference]: Finished difference Result 79 states and 115 transitions. [2018-11-23 11:32:36,480 INFO L276 IsEmpty]: Start isEmpty. Operand 79 states and 115 transitions. [2018-11-23 11:32:36,481 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:36,482 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:36,482 INFO L74 IsIncluded]: Start isIncluded. First operand 75 states. Second operand 79 states. [2018-11-23 11:32:36,482 INFO L87 Difference]: Start difference. First operand 75 states. Second operand 79 states. [2018-11-23 11:32:36,488 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:36,489 INFO L93 Difference]: Finished difference Result 79 states and 115 transitions. [2018-11-23 11:32:36,489 INFO L276 IsEmpty]: Start isEmpty. Operand 79 states and 115 transitions. [2018-11-23 11:32:36,490 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:36,490 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:36,491 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 11:32:36,491 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 11:32:36,491 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 75 states. [2018-11-23 11:32:36,497 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 75 states to 75 states and 111 transitions. [2018-11-23 11:32:36,497 INFO L78 Accepts]: Start accepts. Automaton has 75 states and 111 transitions. Word has length 23 [2018-11-23 11:32:36,497 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 11:32:36,498 INFO L480 AbstractCegarLoop]: Abstraction has 75 states and 111 transitions. [2018-11-23 11:32:36,498 INFO L481 AbstractCegarLoop]: Interpolant automaton has 7 states. [2018-11-23 11:32:36,498 INFO L276 IsEmpty]: Start isEmpty. Operand 75 states and 111 transitions. [2018-11-23 11:32:36,499 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 42 [2018-11-23 11:32:36,499 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 11:32:36,499 INFO L402 BasicCegarLoop]: trace histogram [6, 5, 5, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 11:32:36,500 INFO L423 AbstractCegarLoop]: === Iteration 5 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 11:32:36,500 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 11:32:36,500 INFO L82 PathProgramCache]: Analyzing trace with hash 850180462, now seen corresponding path program 1 times [2018-11-23 11:32:36,501 INFO L223 ckRefinementStrategy]: Switched to mode CVC4_FPBP [2018-11-23 11:32:36,501 INFO L69 tionRefinementEngine]: Using refinement strategy WolfRefinementStrategy No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/cvc4nyu Starting monitored process 6 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 6 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk [2018-11-23 11:32:36,524 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 11:32:36,574 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:36,607 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:36,608 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 11:32:36,749 INFO L256 TraceCheckUtils]: 0: Hoare triple {1527#true} call ULTIMATE.init(); {1527#true} is VALID [2018-11-23 11:32:36,750 INFO L273 TraceCheckUtils]: 1: Hoare triple {1527#true} assume true; {1527#true} is VALID [2018-11-23 11:32:36,750 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {1527#true} {1527#true} #77#return; {1527#true} is VALID [2018-11-23 11:32:36,751 INFO L256 TraceCheckUtils]: 3: Hoare triple {1527#true} call #t~ret11 := main(); {1527#true} is VALID [2018-11-23 11:32:36,752 INFO L273 TraceCheckUtils]: 4: Hoare triple {1527#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {1527#true} is VALID [2018-11-23 11:32:36,755 INFO L273 TraceCheckUtils]: 5: Hoare triple {1527#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {1547#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:32:36,756 INFO L273 TraceCheckUtils]: 6: Hoare triple {1547#(= main_~i~0 (_ bv0 32))} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {1551#(and (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} is VALID [2018-11-23 11:32:36,757 INFO L273 TraceCheckUtils]: 7: Hoare triple {1551#(and (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {1551#(and (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} is VALID [2018-11-23 11:32:36,757 INFO L273 TraceCheckUtils]: 8: Hoare triple {1551#(and (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {1558#(and (not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)) (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} is VALID [2018-11-23 11:32:36,757 INFO L256 TraceCheckUtils]: 9: Hoare triple {1558#(and (not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)) (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {1527#true} is VALID [2018-11-23 11:32:36,758 INFO L273 TraceCheckUtils]: 10: Hoare triple {1527#true} ~cond := #in~cond; {1527#true} is VALID [2018-11-23 11:32:36,758 INFO L273 TraceCheckUtils]: 11: Hoare triple {1527#true} assume !(0bv32 == ~cond); {1527#true} is VALID [2018-11-23 11:32:36,758 INFO L273 TraceCheckUtils]: 12: Hoare triple {1527#true} assume true; {1527#true} is VALID [2018-11-23 11:32:36,760 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {1527#true} {1558#(and (not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)) (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} #105#return; {1558#(and (not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)) (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} is VALID [2018-11-23 11:32:36,760 INFO L256 TraceCheckUtils]: 14: Hoare triple {1558#(and (not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)) (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {1527#true} is VALID [2018-11-23 11:32:36,760 INFO L273 TraceCheckUtils]: 15: Hoare triple {1527#true} ~cond := #in~cond; {1527#true} is VALID [2018-11-23 11:32:36,761 INFO L273 TraceCheckUtils]: 16: Hoare triple {1527#true} assume !(0bv32 == ~cond); {1527#true} is VALID [2018-11-23 11:32:36,761 INFO L273 TraceCheckUtils]: 17: Hoare triple {1527#true} assume true; {1527#true} is VALID [2018-11-23 11:32:36,762 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {1527#true} {1558#(and (not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)) (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} #107#return; {1558#(and (not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)) (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} is VALID [2018-11-23 11:32:36,763 INFO L256 TraceCheckUtils]: 19: Hoare triple {1558#(and (not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)) (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {1527#true} is VALID [2018-11-23 11:32:36,763 INFO L273 TraceCheckUtils]: 20: Hoare triple {1527#true} ~cond := #in~cond; {1527#true} is VALID [2018-11-23 11:32:36,763 INFO L273 TraceCheckUtils]: 21: Hoare triple {1527#true} assume !(0bv32 == ~cond); {1527#true} is VALID [2018-11-23 11:32:36,764 INFO L273 TraceCheckUtils]: 22: Hoare triple {1527#true} assume true; {1527#true} is VALID [2018-11-23 11:32:36,771 INFO L268 TraceCheckUtils]: 23: Hoare quadruple {1527#true} {1558#(and (not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)) (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} #109#return; {1558#(and (not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)) (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} is VALID [2018-11-23 11:32:36,772 INFO L256 TraceCheckUtils]: 24: Hoare triple {1558#(and (not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)) (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {1527#true} is VALID [2018-11-23 11:32:36,772 INFO L273 TraceCheckUtils]: 25: Hoare triple {1527#true} ~cond := #in~cond; {1527#true} is VALID [2018-11-23 11:32:36,773 INFO L273 TraceCheckUtils]: 26: Hoare triple {1527#true} assume !(0bv32 == ~cond); {1527#true} is VALID [2018-11-23 11:32:36,773 INFO L273 TraceCheckUtils]: 27: Hoare triple {1527#true} assume true; {1527#true} is VALID [2018-11-23 11:32:36,776 INFO L268 TraceCheckUtils]: 28: Hoare quadruple {1527#true} {1558#(and (not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)) (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} #111#return; {1558#(and (not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)) (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} is VALID [2018-11-23 11:32:36,777 INFO L273 TraceCheckUtils]: 29: Hoare triple {1558#(and (not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)) (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} #t~post9 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post9);havoc #t~post9;#t~post10 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post10);havoc #t~post10; {1622#(and (bvslt (_ bv0 32) main_~len~0) (not (bvslt (_ bv1 32) main_~len~0)) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:36,781 INFO L273 TraceCheckUtils]: 30: Hoare triple {1622#(and (bvslt (_ bv0 32) main_~len~0) (not (bvslt (_ bv1 32) main_~len~0)) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {1528#false} is VALID [2018-11-23 11:32:36,781 INFO L273 TraceCheckUtils]: 31: Hoare triple {1528#false} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {1528#false} is VALID [2018-11-23 11:32:36,781 INFO L256 TraceCheckUtils]: 32: Hoare triple {1528#false} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {1528#false} is VALID [2018-11-23 11:32:36,781 INFO L273 TraceCheckUtils]: 33: Hoare triple {1528#false} ~cond := #in~cond; {1528#false} is VALID [2018-11-23 11:32:36,782 INFO L273 TraceCheckUtils]: 34: Hoare triple {1528#false} assume !(0bv32 == ~cond); {1528#false} is VALID [2018-11-23 11:32:36,782 INFO L273 TraceCheckUtils]: 35: Hoare triple {1528#false} assume true; {1528#false} is VALID [2018-11-23 11:32:36,782 INFO L268 TraceCheckUtils]: 36: Hoare quadruple {1528#false} {1528#false} #105#return; {1528#false} is VALID [2018-11-23 11:32:36,782 INFO L256 TraceCheckUtils]: 37: Hoare triple {1528#false} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {1528#false} is VALID [2018-11-23 11:32:36,783 INFO L273 TraceCheckUtils]: 38: Hoare triple {1528#false} ~cond := #in~cond; {1528#false} is VALID [2018-11-23 11:32:36,783 INFO L273 TraceCheckUtils]: 39: Hoare triple {1528#false} assume 0bv32 == ~cond; {1528#false} is VALID [2018-11-23 11:32:36,783 INFO L273 TraceCheckUtils]: 40: Hoare triple {1528#false} assume !false; {1528#false} is VALID [2018-11-23 11:32:36,788 INFO L134 CoverageAnalysis]: Checked inductivity of 54 backedges. 27 proven. 1 refuted. 0 times theorem prover too weak. 26 trivial. 0 not checked. [2018-11-23 11:32:36,788 INFO L316 TraceCheckSpWp]: Computing backward predicates... [2018-11-23 11:32:36,939 INFO L273 TraceCheckUtils]: 40: Hoare triple {1528#false} assume !false; {1528#false} is VALID [2018-11-23 11:32:36,940 INFO L273 TraceCheckUtils]: 39: Hoare triple {1528#false} assume 0bv32 == ~cond; {1528#false} is VALID [2018-11-23 11:32:36,940 INFO L273 TraceCheckUtils]: 38: Hoare triple {1528#false} ~cond := #in~cond; {1528#false} is VALID [2018-11-23 11:32:36,940 INFO L256 TraceCheckUtils]: 37: Hoare triple {1528#false} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {1528#false} is VALID [2018-11-23 11:32:36,940 INFO L268 TraceCheckUtils]: 36: Hoare quadruple {1527#true} {1528#false} #105#return; {1528#false} is VALID [2018-11-23 11:32:36,941 INFO L273 TraceCheckUtils]: 35: Hoare triple {1527#true} assume true; {1527#true} is VALID [2018-11-23 11:32:36,941 INFO L273 TraceCheckUtils]: 34: Hoare triple {1527#true} assume !(0bv32 == ~cond); {1527#true} is VALID [2018-11-23 11:32:36,941 INFO L273 TraceCheckUtils]: 33: Hoare triple {1527#true} ~cond := #in~cond; {1527#true} is VALID [2018-11-23 11:32:36,941 INFO L256 TraceCheckUtils]: 32: Hoare triple {1528#false} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {1527#true} is VALID [2018-11-23 11:32:36,942 INFO L273 TraceCheckUtils]: 31: Hoare triple {1528#false} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {1528#false} is VALID [2018-11-23 11:32:36,942 INFO L273 TraceCheckUtils]: 30: Hoare triple {1686#(not (bvslt main_~i~0 main_~len~0))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {1528#false} is VALID [2018-11-23 11:32:36,944 INFO L273 TraceCheckUtils]: 29: Hoare triple {1690#(not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #t~post9 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post9);havoc #t~post9;#t~post10 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post10);havoc #t~post10; {1686#(not (bvslt main_~i~0 main_~len~0))} is VALID [2018-11-23 11:32:36,945 INFO L268 TraceCheckUtils]: 28: Hoare quadruple {1527#true} {1690#(not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #111#return; {1690#(not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:36,945 INFO L273 TraceCheckUtils]: 27: Hoare triple {1527#true} assume true; {1527#true} is VALID [2018-11-23 11:32:36,945 INFO L273 TraceCheckUtils]: 26: Hoare triple {1527#true} assume !(0bv32 == ~cond); {1527#true} is VALID [2018-11-23 11:32:36,946 INFO L273 TraceCheckUtils]: 25: Hoare triple {1527#true} ~cond := #in~cond; {1527#true} is VALID [2018-11-23 11:32:36,946 INFO L256 TraceCheckUtils]: 24: Hoare triple {1690#(not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {1527#true} is VALID [2018-11-23 11:32:36,960 INFO L268 TraceCheckUtils]: 23: Hoare quadruple {1527#true} {1690#(not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #109#return; {1690#(not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:36,961 INFO L273 TraceCheckUtils]: 22: Hoare triple {1527#true} assume true; {1527#true} is VALID [2018-11-23 11:32:36,961 INFO L273 TraceCheckUtils]: 21: Hoare triple {1527#true} assume !(0bv32 == ~cond); {1527#true} is VALID [2018-11-23 11:32:36,962 INFO L273 TraceCheckUtils]: 20: Hoare triple {1527#true} ~cond := #in~cond; {1527#true} is VALID [2018-11-23 11:32:36,962 INFO L256 TraceCheckUtils]: 19: Hoare triple {1690#(not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {1527#true} is VALID [2018-11-23 11:32:36,969 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {1527#true} {1690#(not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #107#return; {1690#(not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:36,969 INFO L273 TraceCheckUtils]: 17: Hoare triple {1527#true} assume true; {1527#true} is VALID [2018-11-23 11:32:36,969 INFO L273 TraceCheckUtils]: 16: Hoare triple {1527#true} assume !(0bv32 == ~cond); {1527#true} is VALID [2018-11-23 11:32:36,970 INFO L273 TraceCheckUtils]: 15: Hoare triple {1527#true} ~cond := #in~cond; {1527#true} is VALID [2018-11-23 11:32:36,970 INFO L256 TraceCheckUtils]: 14: Hoare triple {1690#(not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {1527#true} is VALID [2018-11-23 11:32:36,971 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {1527#true} {1690#(not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #105#return; {1690#(not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:36,971 INFO L273 TraceCheckUtils]: 12: Hoare triple {1527#true} assume true; {1527#true} is VALID [2018-11-23 11:32:36,971 INFO L273 TraceCheckUtils]: 11: Hoare triple {1527#true} assume !(0bv32 == ~cond); {1527#true} is VALID [2018-11-23 11:32:36,971 INFO L273 TraceCheckUtils]: 10: Hoare triple {1527#true} ~cond := #in~cond; {1527#true} is VALID [2018-11-23 11:32:36,972 INFO L256 TraceCheckUtils]: 9: Hoare triple {1690#(not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {1527#true} is VALID [2018-11-23 11:32:36,972 INFO L273 TraceCheckUtils]: 8: Hoare triple {1527#true} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {1690#(not (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:36,973 INFO L273 TraceCheckUtils]: 7: Hoare triple {1527#true} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {1527#true} is VALID [2018-11-23 11:32:36,973 INFO L273 TraceCheckUtils]: 6: Hoare triple {1527#true} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {1527#true} is VALID [2018-11-23 11:32:36,973 INFO L273 TraceCheckUtils]: 5: Hoare triple {1527#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {1527#true} is VALID [2018-11-23 11:32:36,973 INFO L273 TraceCheckUtils]: 4: Hoare triple {1527#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {1527#true} is VALID [2018-11-23 11:32:36,974 INFO L256 TraceCheckUtils]: 3: Hoare triple {1527#true} call #t~ret11 := main(); {1527#true} is VALID [2018-11-23 11:32:36,974 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {1527#true} {1527#true} #77#return; {1527#true} is VALID [2018-11-23 11:32:36,974 INFO L273 TraceCheckUtils]: 1: Hoare triple {1527#true} assume true; {1527#true} is VALID [2018-11-23 11:32:36,974 INFO L256 TraceCheckUtils]: 0: Hoare triple {1527#true} call ULTIMATE.init(); {1527#true} is VALID [2018-11-23 11:32:36,978 INFO L134 CoverageAnalysis]: Checked inductivity of 54 backedges. 14 proven. 0 refuted. 0 times theorem prover too weak. 40 trivial. 0 not checked. [2018-11-23 11:32:36,981 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 1 imperfect interpolant sequences. [2018-11-23 11:32:36,981 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [4] imperfect sequences [6] total 8 [2018-11-23 11:32:36,982 INFO L78 Accepts]: Start accepts. Automaton has 8 states. Word has length 41 [2018-11-23 11:32:36,983 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 11:32:36,983 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 8 states. [2018-11-23 11:32:37,092 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 47 edges. 47 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:37,092 INFO L459 AbstractCegarLoop]: Interpolant automaton has 8 states [2018-11-23 11:32:37,092 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 8 interpolants. [2018-11-23 11:32:37,092 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=19, Invalid=37, Unknown=0, NotChecked=0, Total=56 [2018-11-23 11:32:37,093 INFO L87 Difference]: Start difference. First operand 75 states and 111 transitions. Second operand 8 states. [2018-11-23 11:32:38,814 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:38,814 INFO L93 Difference]: Finished difference Result 155 states and 237 transitions. [2018-11-23 11:32:38,814 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 8 states. [2018-11-23 11:32:38,814 INFO L78 Accepts]: Start accepts. Automaton has 8 states. Word has length 41 [2018-11-23 11:32:38,815 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 11:32:38,815 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 8 states. [2018-11-23 11:32:38,820 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 8 states to 8 states and 156 transitions. [2018-11-23 11:32:38,820 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 8 states. [2018-11-23 11:32:38,825 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 8 states to 8 states and 156 transitions. [2018-11-23 11:32:38,825 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 8 states and 156 transitions. [2018-11-23 11:32:39,138 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 156 edges. 156 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:39,144 INFO L225 Difference]: With dead ends: 155 [2018-11-23 11:32:39,144 INFO L226 Difference]: Without dead ends: 88 [2018-11-23 11:32:39,146 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 81 GetRequests, 75 SyntacticMatches, 0 SemanticMatches, 6 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 6 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=19, Invalid=37, Unknown=0, NotChecked=0, Total=56 [2018-11-23 11:32:39,146 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 88 states. [2018-11-23 11:32:39,297 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 88 to 81. [2018-11-23 11:32:39,297 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 11:32:39,297 INFO L82 GeneralOperation]: Start isEquivalent. First operand 88 states. Second operand 81 states. [2018-11-23 11:32:39,298 INFO L74 IsIncluded]: Start isIncluded. First operand 88 states. Second operand 81 states. [2018-11-23 11:32:39,298 INFO L87 Difference]: Start difference. First operand 88 states. Second operand 81 states. [2018-11-23 11:32:39,304 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:39,305 INFO L93 Difference]: Finished difference Result 88 states and 131 transitions. [2018-11-23 11:32:39,305 INFO L276 IsEmpty]: Start isEmpty. Operand 88 states and 131 transitions. [2018-11-23 11:32:39,306 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:39,306 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:39,306 INFO L74 IsIncluded]: Start isIncluded. First operand 81 states. Second operand 88 states. [2018-11-23 11:32:39,307 INFO L87 Difference]: Start difference. First operand 81 states. Second operand 88 states. [2018-11-23 11:32:39,312 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:39,313 INFO L93 Difference]: Finished difference Result 88 states and 131 transitions. [2018-11-23 11:32:39,313 INFO L276 IsEmpty]: Start isEmpty. Operand 88 states and 131 transitions. [2018-11-23 11:32:39,314 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:39,314 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:39,314 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 11:32:39,314 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 11:32:39,315 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 81 states. [2018-11-23 11:32:39,319 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 81 states to 81 states and 120 transitions. [2018-11-23 11:32:39,319 INFO L78 Accepts]: Start accepts. Automaton has 81 states and 120 transitions. Word has length 41 [2018-11-23 11:32:39,320 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 11:32:39,320 INFO L480 AbstractCegarLoop]: Abstraction has 81 states and 120 transitions. [2018-11-23 11:32:39,320 INFO L481 AbstractCegarLoop]: Interpolant automaton has 8 states. [2018-11-23 11:32:39,320 INFO L276 IsEmpty]: Start isEmpty. Operand 81 states and 120 transitions. [2018-11-23 11:32:39,321 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 46 [2018-11-23 11:32:39,322 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 11:32:39,322 INFO L402 BasicCegarLoop]: trace histogram [7, 6, 6, 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-11-23 11:32:39,322 INFO L423 AbstractCegarLoop]: === Iteration 6 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 11:32:39,322 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 11:32:39,322 INFO L82 PathProgramCache]: Analyzing trace with hash 1704087969, now seen corresponding path program 1 times [2018-11-23 11:32:39,323 INFO L223 ckRefinementStrategy]: Switched to mode CVC4_FPBP [2018-11-23 11:32:39,323 INFO L69 tionRefinementEngine]: Using refinement strategy WolfRefinementStrategy No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/cvc4nyu Starting monitored process 7 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 7 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk [2018-11-23 11:32:39,351 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 11:32:39,390 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:39,410 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:39,412 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 11:32:39,598 INFO L256 TraceCheckUtils]: 0: Hoare triple {2344#true} call ULTIMATE.init(); {2344#true} is VALID [2018-11-23 11:32:39,598 INFO L273 TraceCheckUtils]: 1: Hoare triple {2344#true} assume true; {2344#true} is VALID [2018-11-23 11:32:39,599 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {2344#true} {2344#true} #77#return; {2344#true} is VALID [2018-11-23 11:32:39,599 INFO L256 TraceCheckUtils]: 3: Hoare triple {2344#true} call #t~ret11 := main(); {2344#true} is VALID [2018-11-23 11:32:39,599 INFO L273 TraceCheckUtils]: 4: Hoare triple {2344#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {2344#true} is VALID [2018-11-23 11:32:39,608 INFO L273 TraceCheckUtils]: 5: Hoare triple {2344#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {2364#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:32:39,621 INFO L273 TraceCheckUtils]: 6: Hoare triple {2364#(= main_~i~0 (_ bv0 32))} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {2368#(and (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} is VALID [2018-11-23 11:32:39,636 INFO L273 TraceCheckUtils]: 7: Hoare triple {2368#(and (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {2368#(and (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} is VALID [2018-11-23 11:32:39,645 INFO L273 TraceCheckUtils]: 8: Hoare triple {2368#(and (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:39,645 INFO L256 TraceCheckUtils]: 9: Hoare triple {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {2344#true} is VALID [2018-11-23 11:32:39,646 INFO L273 TraceCheckUtils]: 10: Hoare triple {2344#true} ~cond := #in~cond; {2344#true} is VALID [2018-11-23 11:32:39,646 INFO L273 TraceCheckUtils]: 11: Hoare triple {2344#true} assume !(0bv32 == ~cond); {2344#true} is VALID [2018-11-23 11:32:39,646 INFO L273 TraceCheckUtils]: 12: Hoare triple {2344#true} assume true; {2344#true} is VALID [2018-11-23 11:32:39,659 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {2344#true} {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #81#return; {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:39,659 INFO L256 TraceCheckUtils]: 14: Hoare triple {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {2344#true} is VALID [2018-11-23 11:32:39,660 INFO L273 TraceCheckUtils]: 15: Hoare triple {2344#true} ~cond := #in~cond; {2344#true} is VALID [2018-11-23 11:32:39,660 INFO L273 TraceCheckUtils]: 16: Hoare triple {2344#true} assume !(0bv32 == ~cond); {2344#true} is VALID [2018-11-23 11:32:39,660 INFO L273 TraceCheckUtils]: 17: Hoare triple {2344#true} assume true; {2344#true} is VALID [2018-11-23 11:32:39,673 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {2344#true} {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #83#return; {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:39,686 INFO L273 TraceCheckUtils]: 19: Hoare triple {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:39,686 INFO L256 TraceCheckUtils]: 20: Hoare triple {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {2344#true} is VALID [2018-11-23 11:32:39,687 INFO L273 TraceCheckUtils]: 21: Hoare triple {2344#true} ~cond := #in~cond; {2344#true} is VALID [2018-11-23 11:32:39,687 INFO L273 TraceCheckUtils]: 22: Hoare triple {2344#true} assume !(0bv32 == ~cond); {2344#true} is VALID [2018-11-23 11:32:39,687 INFO L273 TraceCheckUtils]: 23: Hoare triple {2344#true} assume true; {2344#true} is VALID [2018-11-23 11:32:39,700 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {2344#true} {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #85#return; {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:39,700 INFO L256 TraceCheckUtils]: 25: Hoare triple {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {2344#true} is VALID [2018-11-23 11:32:39,701 INFO L273 TraceCheckUtils]: 26: Hoare triple {2344#true} ~cond := #in~cond; {2344#true} is VALID [2018-11-23 11:32:39,701 INFO L273 TraceCheckUtils]: 27: Hoare triple {2344#true} assume !(0bv32 == ~cond); {2344#true} is VALID [2018-11-23 11:32:39,701 INFO L273 TraceCheckUtils]: 28: Hoare triple {2344#true} assume true; {2344#true} is VALID [2018-11-23 11:32:39,714 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {2344#true} {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #87#return; {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:39,714 INFO L256 TraceCheckUtils]: 30: Hoare triple {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {2344#true} is VALID [2018-11-23 11:32:39,715 INFO L273 TraceCheckUtils]: 31: Hoare triple {2344#true} ~cond := #in~cond; {2344#true} is VALID [2018-11-23 11:32:39,715 INFO L273 TraceCheckUtils]: 32: Hoare triple {2344#true} assume !(0bv32 == ~cond); {2344#true} is VALID [2018-11-23 11:32:39,715 INFO L273 TraceCheckUtils]: 33: Hoare triple {2344#true} assume true; {2344#true} is VALID [2018-11-23 11:32:39,721 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {2344#true} {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #89#return; {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:39,721 INFO L256 TraceCheckUtils]: 35: Hoare triple {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {2344#true} is VALID [2018-11-23 11:32:39,721 INFO L273 TraceCheckUtils]: 36: Hoare triple {2344#true} ~cond := #in~cond; {2344#true} is VALID [2018-11-23 11:32:39,722 INFO L273 TraceCheckUtils]: 37: Hoare triple {2344#true} assume !(0bv32 == ~cond); {2344#true} is VALID [2018-11-23 11:32:39,722 INFO L273 TraceCheckUtils]: 38: Hoare triple {2344#true} assume true; {2344#true} is VALID [2018-11-23 11:32:39,723 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {2344#true} {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #91#return; {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:39,723 INFO L273 TraceCheckUtils]: 40: Hoare triple {2375#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {2472#(and (bvslt (_ bv1 32) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:39,725 INFO L256 TraceCheckUtils]: 41: Hoare triple {2472#(and (bvslt (_ bv1 32) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {2476#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:39,726 INFO L273 TraceCheckUtils]: 42: Hoare triple {2476#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} ~cond := #in~cond; {2480#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:39,731 INFO L273 TraceCheckUtils]: 43: Hoare triple {2480#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} assume 0bv32 == ~cond; {2345#false} is VALID [2018-11-23 11:32:39,732 INFO L273 TraceCheckUtils]: 44: Hoare triple {2345#false} assume !false; {2345#false} is VALID [2018-11-23 11:32:39,735 INFO L134 CoverageAnalysis]: Checked inductivity of 72 backedges. 12 proven. 0 refuted. 0 times theorem prover too weak. 60 trivial. 0 not checked. [2018-11-23 11:32:39,735 INFO L312 TraceCheckSpWp]: Omiting computation of backward sequence because forward sequence was already perfect [MP cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (7)] Exception during sending of exit command (exit): Broken pipe [2018-11-23 11:32:39,741 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 11:32:39,741 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [8] imperfect sequences [] total 8 [2018-11-23 11:32:39,742 INFO L78 Accepts]: Start accepts. Automaton has 8 states. Word has length 45 [2018-11-23 11:32:39,742 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 11:32:39,742 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 8 states. [2018-11-23 11:32:39,806 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 30 edges. 30 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:39,806 INFO L459 AbstractCegarLoop]: Interpolant automaton has 8 states [2018-11-23 11:32:39,807 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 8 interpolants. [2018-11-23 11:32:39,807 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=16, Invalid=40, Unknown=0, NotChecked=0, Total=56 [2018-11-23 11:32:39,807 INFO L87 Difference]: Start difference. First operand 81 states and 120 transitions. Second operand 8 states. [2018-11-23 11:32:42,129 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:42,130 INFO L93 Difference]: Finished difference Result 142 states and 216 transitions. [2018-11-23 11:32:42,130 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 8 states. [2018-11-23 11:32:42,130 INFO L78 Accepts]: Start accepts. Automaton has 8 states. Word has length 45 [2018-11-23 11:32:42,130 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 11:32:42,131 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 8 states. [2018-11-23 11:32:42,135 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 8 states to 8 states and 126 transitions. [2018-11-23 11:32:42,135 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 8 states. [2018-11-23 11:32:42,141 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 8 states to 8 states and 126 transitions. [2018-11-23 11:32:42,141 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 8 states and 126 transitions. [2018-11-23 11:32:42,331 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 126 edges. 126 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:42,337 INFO L225 Difference]: With dead ends: 142 [2018-11-23 11:32:42,337 INFO L226 Difference]: Without dead ends: 138 [2018-11-23 11:32:42,338 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 45 GetRequests, 38 SyntacticMatches, 0 SemanticMatches, 7 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 8 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=20, Invalid=52, Unknown=0, NotChecked=0, Total=72 [2018-11-23 11:32:42,338 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 138 states. [2018-11-23 11:32:42,908 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 138 to 122. [2018-11-23 11:32:42,909 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 11:32:42,909 INFO L82 GeneralOperation]: Start isEquivalent. First operand 138 states. Second operand 122 states. [2018-11-23 11:32:42,909 INFO L74 IsIncluded]: Start isIncluded. First operand 138 states. Second operand 122 states. [2018-11-23 11:32:42,909 INFO L87 Difference]: Start difference. First operand 138 states. Second operand 122 states. [2018-11-23 11:32:42,918 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:42,919 INFO L93 Difference]: Finished difference Result 138 states and 210 transitions. [2018-11-23 11:32:42,919 INFO L276 IsEmpty]: Start isEmpty. Operand 138 states and 210 transitions. [2018-11-23 11:32:42,920 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:42,920 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:42,920 INFO L74 IsIncluded]: Start isIncluded. First operand 122 states. Second operand 138 states. [2018-11-23 11:32:42,921 INFO L87 Difference]: Start difference. First operand 122 states. Second operand 138 states. [2018-11-23 11:32:42,929 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:42,930 INFO L93 Difference]: Finished difference Result 138 states and 210 transitions. [2018-11-23 11:32:42,930 INFO L276 IsEmpty]: Start isEmpty. Operand 138 states and 210 transitions. [2018-11-23 11:32:42,931 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:42,931 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:42,931 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 11:32:42,931 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 11:32:42,932 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 122 states. [2018-11-23 11:32:42,938 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 122 states to 122 states and 183 transitions. [2018-11-23 11:32:42,939 INFO L78 Accepts]: Start accepts. Automaton has 122 states and 183 transitions. Word has length 45 [2018-11-23 11:32:42,939 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 11:32:42,939 INFO L480 AbstractCegarLoop]: Abstraction has 122 states and 183 transitions. [2018-11-23 11:32:42,939 INFO L481 AbstractCegarLoop]: Interpolant automaton has 8 states. [2018-11-23 11:32:42,939 INFO L276 IsEmpty]: Start isEmpty. Operand 122 states and 183 transitions. [2018-11-23 11:32:42,940 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 56 [2018-11-23 11:32:42,940 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 11:32:42,941 INFO L402 BasicCegarLoop]: trace histogram [9, 8, 8, 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-11-23 11:32:42,941 INFO L423 AbstractCegarLoop]: === Iteration 7 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 11:32:42,941 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 11:32:42,941 INFO L82 PathProgramCache]: Analyzing trace with hash 1365911905, now seen corresponding path program 1 times [2018-11-23 11:32:42,942 INFO L223 ckRefinementStrategy]: Switched to mode CVC4_FPBP [2018-11-23 11:32:42,942 INFO L69 tionRefinementEngine]: Using refinement strategy WolfRefinementStrategy No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/cvc4nyu Starting monitored process 8 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 8 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk [2018-11-23 11:32:42,971 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 11:32:43,012 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:43,028 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:43,030 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 11:32:43,294 INFO L256 TraceCheckUtils]: 0: Hoare triple {3199#true} call ULTIMATE.init(); {3199#true} is VALID [2018-11-23 11:32:43,295 INFO L273 TraceCheckUtils]: 1: Hoare triple {3199#true} assume true; {3199#true} is VALID [2018-11-23 11:32:43,295 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {3199#true} {3199#true} #77#return; {3199#true} is VALID [2018-11-23 11:32:43,295 INFO L256 TraceCheckUtils]: 3: Hoare triple {3199#true} call #t~ret11 := main(); {3199#true} is VALID [2018-11-23 11:32:43,295 INFO L273 TraceCheckUtils]: 4: Hoare triple {3199#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {3199#true} is VALID [2018-11-23 11:32:43,296 INFO L273 TraceCheckUtils]: 5: Hoare triple {3199#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {3219#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} is VALID [2018-11-23 11:32:43,296 INFO L273 TraceCheckUtils]: 6: Hoare triple {3219#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {3223#(and (= main_~j~0 (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} is VALID [2018-11-23 11:32:43,297 INFO L273 TraceCheckUtils]: 7: Hoare triple {3223#(and (= main_~j~0 (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:43,297 INFO L273 TraceCheckUtils]: 8: Hoare triple {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:43,298 INFO L256 TraceCheckUtils]: 9: Hoare triple {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {3199#true} is VALID [2018-11-23 11:32:43,298 INFO L273 TraceCheckUtils]: 10: Hoare triple {3199#true} ~cond := #in~cond; {3199#true} is VALID [2018-11-23 11:32:43,298 INFO L273 TraceCheckUtils]: 11: Hoare triple {3199#true} assume !(0bv32 == ~cond); {3199#true} is VALID [2018-11-23 11:32:43,298 INFO L273 TraceCheckUtils]: 12: Hoare triple {3199#true} assume true; {3199#true} is VALID [2018-11-23 11:32:43,304 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {3199#true} {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #81#return; {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:43,304 INFO L256 TraceCheckUtils]: 14: Hoare triple {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {3199#true} is VALID [2018-11-23 11:32:43,305 INFO L273 TraceCheckUtils]: 15: Hoare triple {3199#true} ~cond := #in~cond; {3199#true} is VALID [2018-11-23 11:32:43,305 INFO L273 TraceCheckUtils]: 16: Hoare triple {3199#true} assume !(0bv32 == ~cond); {3199#true} is VALID [2018-11-23 11:32:43,305 INFO L273 TraceCheckUtils]: 17: Hoare triple {3199#true} assume true; {3199#true} is VALID [2018-11-23 11:32:43,306 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {3199#true} {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #83#return; {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:43,307 INFO L273 TraceCheckUtils]: 19: Hoare triple {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:43,307 INFO L256 TraceCheckUtils]: 20: Hoare triple {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {3199#true} is VALID [2018-11-23 11:32:43,307 INFO L273 TraceCheckUtils]: 21: Hoare triple {3199#true} ~cond := #in~cond; {3199#true} is VALID [2018-11-23 11:32:43,307 INFO L273 TraceCheckUtils]: 22: Hoare triple {3199#true} assume !(0bv32 == ~cond); {3199#true} is VALID [2018-11-23 11:32:43,307 INFO L273 TraceCheckUtils]: 23: Hoare triple {3199#true} assume true; {3199#true} is VALID [2018-11-23 11:32:43,308 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {3199#true} {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #85#return; {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:43,309 INFO L256 TraceCheckUtils]: 25: Hoare triple {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {3199#true} is VALID [2018-11-23 11:32:43,309 INFO L273 TraceCheckUtils]: 26: Hoare triple {3199#true} ~cond := #in~cond; {3199#true} is VALID [2018-11-23 11:32:43,309 INFO L273 TraceCheckUtils]: 27: Hoare triple {3199#true} assume !(0bv32 == ~cond); {3199#true} is VALID [2018-11-23 11:32:43,309 INFO L273 TraceCheckUtils]: 28: Hoare triple {3199#true} assume true; {3199#true} is VALID [2018-11-23 11:32:43,310 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {3199#true} {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #87#return; {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:43,310 INFO L256 TraceCheckUtils]: 30: Hoare triple {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {3199#true} is VALID [2018-11-23 11:32:43,310 INFO L273 TraceCheckUtils]: 31: Hoare triple {3199#true} ~cond := #in~cond; {3199#true} is VALID [2018-11-23 11:32:43,311 INFO L273 TraceCheckUtils]: 32: Hoare triple {3199#true} assume !(0bv32 == ~cond); {3199#true} is VALID [2018-11-23 11:32:43,311 INFO L273 TraceCheckUtils]: 33: Hoare triple {3199#true} assume true; {3199#true} is VALID [2018-11-23 11:32:43,312 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {3199#true} {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #89#return; {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:43,312 INFO L256 TraceCheckUtils]: 35: Hoare triple {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {3199#true} is VALID [2018-11-23 11:32:43,312 INFO L273 TraceCheckUtils]: 36: Hoare triple {3199#true} ~cond := #in~cond; {3199#true} is VALID [2018-11-23 11:32:43,312 INFO L273 TraceCheckUtils]: 37: Hoare triple {3199#true} assume !(0bv32 == ~cond); {3199#true} is VALID [2018-11-23 11:32:43,313 INFO L273 TraceCheckUtils]: 38: Hoare triple {3199#true} assume true; {3199#true} is VALID [2018-11-23 11:32:43,313 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {3199#true} {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #91#return; {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:43,315 INFO L273 TraceCheckUtils]: 40: Hoare triple {3227#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {3327#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:43,315 INFO L256 TraceCheckUtils]: 41: Hoare triple {3327#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {3199#true} is VALID [2018-11-23 11:32:43,315 INFO L273 TraceCheckUtils]: 42: Hoare triple {3199#true} ~cond := #in~cond; {3199#true} is VALID [2018-11-23 11:32:43,316 INFO L273 TraceCheckUtils]: 43: Hoare triple {3199#true} assume !(0bv32 == ~cond); {3199#true} is VALID [2018-11-23 11:32:43,316 INFO L273 TraceCheckUtils]: 44: Hoare triple {3199#true} assume true; {3199#true} is VALID [2018-11-23 11:32:43,317 INFO L268 TraceCheckUtils]: 45: Hoare quadruple {3199#true} {3327#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} #93#return; {3327#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:43,317 INFO L256 TraceCheckUtils]: 46: Hoare triple {3327#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {3199#true} is VALID [2018-11-23 11:32:43,318 INFO L273 TraceCheckUtils]: 47: Hoare triple {3199#true} ~cond := #in~cond; {3199#true} is VALID [2018-11-23 11:32:43,318 INFO L273 TraceCheckUtils]: 48: Hoare triple {3199#true} assume !(0bv32 == ~cond); {3199#true} is VALID [2018-11-23 11:32:43,318 INFO L273 TraceCheckUtils]: 49: Hoare triple {3199#true} assume true; {3199#true} is VALID [2018-11-23 11:32:43,319 INFO L268 TraceCheckUtils]: 50: Hoare quadruple {3199#true} {3327#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} #95#return; {3327#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:43,320 INFO L256 TraceCheckUtils]: 51: Hoare triple {3327#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {3361#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:43,321 INFO L273 TraceCheckUtils]: 52: Hoare triple {3361#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} ~cond := #in~cond; {3365#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:43,322 INFO L273 TraceCheckUtils]: 53: Hoare triple {3365#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} assume 0bv32 == ~cond; {3200#false} is VALID [2018-11-23 11:32:43,322 INFO L273 TraceCheckUtils]: 54: Hoare triple {3200#false} assume !false; {3200#false} is VALID [2018-11-23 11:32:43,327 INFO L134 CoverageAnalysis]: Checked inductivity of 128 backedges. 16 proven. 0 refuted. 0 times theorem prover too weak. 112 trivial. 0 not checked. [2018-11-23 11:32:43,327 INFO L312 TraceCheckSpWp]: Omiting computation of backward sequence because forward sequence was already perfect [2018-11-23 11:32:43,329 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 11:32:43,329 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [8] imperfect sequences [] total 8 [2018-11-23 11:32:43,329 INFO L78 Accepts]: Start accepts. Automaton has 8 states. Word has length 55 [2018-11-23 11:32:43,330 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 11:32:43,330 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 8 states. [2018-11-23 11:32:43,386 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 34 edges. 34 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:43,386 INFO L459 AbstractCegarLoop]: Interpolant automaton has 8 states [2018-11-23 11:32:43,387 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 8 interpolants. [2018-11-23 11:32:43,387 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=14, Invalid=42, Unknown=0, NotChecked=0, Total=56 [2018-11-23 11:32:43,387 INFO L87 Difference]: Start difference. First operand 122 states and 183 transitions. Second operand 8 states. [2018-11-23 11:32:46,572 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:46,572 INFO L93 Difference]: Finished difference Result 160 states and 241 transitions. [2018-11-23 11:32:46,572 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 8 states. [2018-11-23 11:32:46,574 INFO L78 Accepts]: Start accepts. Automaton has 8 states. Word has length 55 [2018-11-23 11:32:46,574 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 11:32:46,577 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 8 states. [2018-11-23 11:32:46,582 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 8 states to 8 states and 129 transitions. [2018-11-23 11:32:46,582 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 8 states. [2018-11-23 11:32:46,587 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 8 states to 8 states and 129 transitions. [2018-11-23 11:32:46,588 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 8 states and 129 transitions. [2018-11-23 11:32:46,980 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 129 edges. 129 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:46,984 INFO L225 Difference]: With dead ends: 160 [2018-11-23 11:32:46,985 INFO L226 Difference]: Without dead ends: 154 [2018-11-23 11:32:46,985 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 57 GetRequests, 48 SyntacticMatches, 0 SemanticMatches, 9 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 8 ImplicationChecksByTransitivity, 0.1s TimeCoverageRelationStatistics Valid=27, Invalid=83, Unknown=0, NotChecked=0, Total=110 [2018-11-23 11:32:46,986 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 154 states. [2018-11-23 11:32:47,270 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 154 to 143. [2018-11-23 11:32:47,270 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 11:32:47,271 INFO L82 GeneralOperation]: Start isEquivalent. First operand 154 states. Second operand 143 states. [2018-11-23 11:32:47,271 INFO L74 IsIncluded]: Start isIncluded. First operand 154 states. Second operand 143 states. [2018-11-23 11:32:47,271 INFO L87 Difference]: Start difference. First operand 154 states. Second operand 143 states. [2018-11-23 11:32:47,281 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:47,281 INFO L93 Difference]: Finished difference Result 154 states and 230 transitions. [2018-11-23 11:32:47,281 INFO L276 IsEmpty]: Start isEmpty. Operand 154 states and 230 transitions. [2018-11-23 11:32:47,283 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:47,283 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:47,283 INFO L74 IsIncluded]: Start isIncluded. First operand 143 states. Second operand 154 states. [2018-11-23 11:32:47,283 INFO L87 Difference]: Start difference. First operand 143 states. Second operand 154 states. [2018-11-23 11:32:47,292 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:47,292 INFO L93 Difference]: Finished difference Result 154 states and 230 transitions. [2018-11-23 11:32:47,292 INFO L276 IsEmpty]: Start isEmpty. Operand 154 states and 230 transitions. [2018-11-23 11:32:47,294 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:47,294 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:47,294 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 11:32:47,294 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 11:32:47,294 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 143 states. [2018-11-23 11:32:47,302 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 143 states to 143 states and 217 transitions. [2018-11-23 11:32:47,302 INFO L78 Accepts]: Start accepts. Automaton has 143 states and 217 transitions. Word has length 55 [2018-11-23 11:32:47,303 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 11:32:47,303 INFO L480 AbstractCegarLoop]: Abstraction has 143 states and 217 transitions. [2018-11-23 11:32:47,303 INFO L481 AbstractCegarLoop]: Interpolant automaton has 8 states. [2018-11-23 11:32:47,303 INFO L276 IsEmpty]: Start isEmpty. Operand 143 states and 217 transitions. [2018-11-23 11:32:47,304 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 67 [2018-11-23 11:32:47,304 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 11:32:47,304 INFO L402 BasicCegarLoop]: trace histogram [11, 10, 10, 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-11-23 11:32:47,305 INFO L423 AbstractCegarLoop]: === Iteration 8 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 11:32:47,305 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 11:32:47,305 INFO L82 PathProgramCache]: Analyzing trace with hash 327277705, now seen corresponding path program 1 times [2018-11-23 11:32:47,305 INFO L223 ckRefinementStrategy]: Switched to mode CVC4_FPBP [2018-11-23 11:32:47,306 INFO L69 tionRefinementEngine]: Using refinement strategy WolfRefinementStrategy No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/cvc4nyu Starting monitored process 9 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 9 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk [2018-11-23 11:32:47,333 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 11:32:47,381 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:47,398 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:47,399 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 11:32:47,732 INFO L256 TraceCheckUtils]: 0: Hoare triple {4184#true} call ULTIMATE.init(); {4184#true} is VALID [2018-11-23 11:32:47,732 INFO L273 TraceCheckUtils]: 1: Hoare triple {4184#true} assume true; {4184#true} is VALID [2018-11-23 11:32:47,733 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {4184#true} {4184#true} #77#return; {4184#true} is VALID [2018-11-23 11:32:47,733 INFO L256 TraceCheckUtils]: 3: Hoare triple {4184#true} call #t~ret11 := main(); {4184#true} is VALID [2018-11-23 11:32:47,733 INFO L273 TraceCheckUtils]: 4: Hoare triple {4184#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {4184#true} is VALID [2018-11-23 11:32:47,735 INFO L273 TraceCheckUtils]: 5: Hoare triple {4184#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {4204#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} is VALID [2018-11-23 11:32:47,746 INFO L273 TraceCheckUtils]: 6: Hoare triple {4204#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {4208#(and (= main_~j~0 (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} is VALID [2018-11-23 11:32:47,748 INFO L273 TraceCheckUtils]: 7: Hoare triple {4208#(and (= main_~j~0 (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:47,748 INFO L273 TraceCheckUtils]: 8: Hoare triple {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:47,748 INFO L256 TraceCheckUtils]: 9: Hoare triple {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {4184#true} is VALID [2018-11-23 11:32:47,749 INFO L273 TraceCheckUtils]: 10: Hoare triple {4184#true} ~cond := #in~cond; {4184#true} is VALID [2018-11-23 11:32:47,749 INFO L273 TraceCheckUtils]: 11: Hoare triple {4184#true} assume !(0bv32 == ~cond); {4184#true} is VALID [2018-11-23 11:32:47,749 INFO L273 TraceCheckUtils]: 12: Hoare triple {4184#true} assume true; {4184#true} is VALID [2018-11-23 11:32:47,749 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {4184#true} {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #81#return; {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:47,750 INFO L256 TraceCheckUtils]: 14: Hoare triple {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {4184#true} is VALID [2018-11-23 11:32:47,750 INFO L273 TraceCheckUtils]: 15: Hoare triple {4184#true} ~cond := #in~cond; {4184#true} is VALID [2018-11-23 11:32:47,750 INFO L273 TraceCheckUtils]: 16: Hoare triple {4184#true} assume !(0bv32 == ~cond); {4184#true} is VALID [2018-11-23 11:32:47,750 INFO L273 TraceCheckUtils]: 17: Hoare triple {4184#true} assume true; {4184#true} is VALID [2018-11-23 11:32:47,751 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {4184#true} {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #83#return; {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:47,751 INFO L273 TraceCheckUtils]: 19: Hoare triple {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:47,751 INFO L256 TraceCheckUtils]: 20: Hoare triple {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {4184#true} is VALID [2018-11-23 11:32:47,751 INFO L273 TraceCheckUtils]: 21: Hoare triple {4184#true} ~cond := #in~cond; {4184#true} is VALID [2018-11-23 11:32:47,752 INFO L273 TraceCheckUtils]: 22: Hoare triple {4184#true} assume !(0bv32 == ~cond); {4184#true} is VALID [2018-11-23 11:32:47,752 INFO L273 TraceCheckUtils]: 23: Hoare triple {4184#true} assume true; {4184#true} is VALID [2018-11-23 11:32:47,753 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {4184#true} {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #85#return; {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:47,753 INFO L256 TraceCheckUtils]: 25: Hoare triple {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {4184#true} is VALID [2018-11-23 11:32:47,753 INFO L273 TraceCheckUtils]: 26: Hoare triple {4184#true} ~cond := #in~cond; {4184#true} is VALID [2018-11-23 11:32:47,753 INFO L273 TraceCheckUtils]: 27: Hoare triple {4184#true} assume !(0bv32 == ~cond); {4184#true} is VALID [2018-11-23 11:32:47,753 INFO L273 TraceCheckUtils]: 28: Hoare triple {4184#true} assume true; {4184#true} is VALID [2018-11-23 11:32:47,754 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {4184#true} {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #87#return; {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:47,754 INFO L256 TraceCheckUtils]: 30: Hoare triple {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {4184#true} is VALID [2018-11-23 11:32:47,754 INFO L273 TraceCheckUtils]: 31: Hoare triple {4184#true} ~cond := #in~cond; {4184#true} is VALID [2018-11-23 11:32:47,755 INFO L273 TraceCheckUtils]: 32: Hoare triple {4184#true} assume !(0bv32 == ~cond); {4184#true} is VALID [2018-11-23 11:32:47,755 INFO L273 TraceCheckUtils]: 33: Hoare triple {4184#true} assume true; {4184#true} is VALID [2018-11-23 11:32:47,756 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {4184#true} {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #89#return; {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:47,756 INFO L256 TraceCheckUtils]: 35: Hoare triple {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {4184#true} is VALID [2018-11-23 11:32:47,756 INFO L273 TraceCheckUtils]: 36: Hoare triple {4184#true} ~cond := #in~cond; {4184#true} is VALID [2018-11-23 11:32:47,756 INFO L273 TraceCheckUtils]: 37: Hoare triple {4184#true} assume !(0bv32 == ~cond); {4184#true} is VALID [2018-11-23 11:32:47,757 INFO L273 TraceCheckUtils]: 38: Hoare triple {4184#true} assume true; {4184#true} is VALID [2018-11-23 11:32:47,757 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {4184#true} {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #91#return; {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:32:47,759 INFO L273 TraceCheckUtils]: 40: Hoare triple {4212#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {4312#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:47,760 INFO L256 TraceCheckUtils]: 41: Hoare triple {4312#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {4184#true} is VALID [2018-11-23 11:32:47,760 INFO L273 TraceCheckUtils]: 42: Hoare triple {4184#true} ~cond := #in~cond; {4184#true} is VALID [2018-11-23 11:32:47,760 INFO L273 TraceCheckUtils]: 43: Hoare triple {4184#true} assume !(0bv32 == ~cond); {4184#true} is VALID [2018-11-23 11:32:47,760 INFO L273 TraceCheckUtils]: 44: Hoare triple {4184#true} assume true; {4184#true} is VALID [2018-11-23 11:32:47,761 INFO L268 TraceCheckUtils]: 45: Hoare quadruple {4184#true} {4312#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} #93#return; {4312#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:47,761 INFO L256 TraceCheckUtils]: 46: Hoare triple {4312#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {4184#true} is VALID [2018-11-23 11:32:47,761 INFO L273 TraceCheckUtils]: 47: Hoare triple {4184#true} ~cond := #in~cond; {4184#true} is VALID [2018-11-23 11:32:47,761 INFO L273 TraceCheckUtils]: 48: Hoare triple {4184#true} assume !(0bv32 == ~cond); {4184#true} is VALID [2018-11-23 11:32:47,761 INFO L273 TraceCheckUtils]: 49: Hoare triple {4184#true} assume true; {4184#true} is VALID [2018-11-23 11:32:47,762 INFO L268 TraceCheckUtils]: 50: Hoare quadruple {4184#true} {4312#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} #95#return; {4312#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:47,762 INFO L256 TraceCheckUtils]: 51: Hoare triple {4312#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {4184#true} is VALID [2018-11-23 11:32:47,762 INFO L273 TraceCheckUtils]: 52: Hoare triple {4184#true} ~cond := #in~cond; {4184#true} is VALID [2018-11-23 11:32:47,763 INFO L273 TraceCheckUtils]: 53: Hoare triple {4184#true} assume !(0bv32 == ~cond); {4184#true} is VALID [2018-11-23 11:32:47,763 INFO L273 TraceCheckUtils]: 54: Hoare triple {4184#true} assume true; {4184#true} is VALID [2018-11-23 11:32:47,763 INFO L268 TraceCheckUtils]: 55: Hoare quadruple {4184#true} {4312#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} #97#return; {4312#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:47,763 INFO L256 TraceCheckUtils]: 56: Hoare triple {4312#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {4184#true} is VALID [2018-11-23 11:32:47,764 INFO L273 TraceCheckUtils]: 57: Hoare triple {4184#true} ~cond := #in~cond; {4184#true} is VALID [2018-11-23 11:32:47,764 INFO L273 TraceCheckUtils]: 58: Hoare triple {4184#true} assume !(0bv32 == ~cond); {4184#true} is VALID [2018-11-23 11:32:47,764 INFO L273 TraceCheckUtils]: 59: Hoare triple {4184#true} assume true; {4184#true} is VALID [2018-11-23 11:32:47,765 INFO L268 TraceCheckUtils]: 60: Hoare quadruple {4184#true} {4312#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} #99#return; {4312#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:47,766 INFO L273 TraceCheckUtils]: 61: Hoare triple {4312#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {4376#(and (= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967294 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))))} is VALID [2018-11-23 11:32:47,768 INFO L256 TraceCheckUtils]: 62: Hoare triple {4376#(and (= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967294 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {4380#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:47,769 INFO L273 TraceCheckUtils]: 63: Hoare triple {4380#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} ~cond := #in~cond; {4384#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:47,769 INFO L273 TraceCheckUtils]: 64: Hoare triple {4384#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} assume 0bv32 == ~cond; {4185#false} is VALID [2018-11-23 11:32:47,770 INFO L273 TraceCheckUtils]: 65: Hoare triple {4185#false} assume !false; {4185#false} is VALID [2018-11-23 11:32:47,774 INFO L134 CoverageAnalysis]: Checked inductivity of 200 backedges. 20 proven. 0 refuted. 0 times theorem prover too weak. 180 trivial. 0 not checked. [2018-11-23 11:32:47,774 INFO L312 TraceCheckSpWp]: Omiting computation of backward sequence because forward sequence was already perfect [2018-11-23 11:32:47,776 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 11:32:47,776 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [9] imperfect sequences [] total 9 [2018-11-23 11:32:47,777 INFO L78 Accepts]: Start accepts. Automaton has 9 states. Word has length 66 [2018-11-23 11:32:47,777 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 11:32:47,777 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 9 states. [2018-11-23 11:32:47,854 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 39 edges. 39 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:47,855 INFO L459 AbstractCegarLoop]: Interpolant automaton has 9 states [2018-11-23 11:32:47,855 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 9 interpolants. [2018-11-23 11:32:47,855 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=16, Invalid=56, Unknown=0, NotChecked=0, Total=72 [2018-11-23 11:32:47,855 INFO L87 Difference]: Start difference. First operand 143 states and 217 transitions. Second operand 9 states. [2018-11-23 11:32:53,467 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:53,467 INFO L93 Difference]: Finished difference Result 188 states and 285 transitions. [2018-11-23 11:32:53,467 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 9 states. [2018-11-23 11:32:53,467 INFO L78 Accepts]: Start accepts. Automaton has 9 states. Word has length 66 [2018-11-23 11:32:53,468 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 11:32:53,468 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 9 states. [2018-11-23 11:32:53,473 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 9 states to 9 states and 172 transitions. [2018-11-23 11:32:53,473 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 9 states. [2018-11-23 11:32:53,477 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 9 states to 9 states and 172 transitions. [2018-11-23 11:32:53,477 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 9 states and 172 transitions. [2018-11-23 11:32:53,961 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 172 edges. 172 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:53,967 INFO L225 Difference]: With dead ends: 188 [2018-11-23 11:32:53,967 INFO L226 Difference]: Without dead ends: 184 [2018-11-23 11:32:53,968 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 69 GetRequests, 58 SyntacticMatches, 0 SemanticMatches, 11 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 12 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=33, Invalid=123, Unknown=0, NotChecked=0, Total=156 [2018-11-23 11:32:53,968 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 184 states. [2018-11-23 11:32:54,918 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 184 to 169. [2018-11-23 11:32:54,919 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 11:32:54,919 INFO L82 GeneralOperation]: Start isEquivalent. First operand 184 states. Second operand 169 states. [2018-11-23 11:32:54,919 INFO L74 IsIncluded]: Start isIncluded. First operand 184 states. Second operand 169 states. [2018-11-23 11:32:54,920 INFO L87 Difference]: Start difference. First operand 184 states. Second operand 169 states. [2018-11-23 11:32:54,931 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:54,932 INFO L93 Difference]: Finished difference Result 184 states and 279 transitions. [2018-11-23 11:32:54,932 INFO L276 IsEmpty]: Start isEmpty. Operand 184 states and 279 transitions. [2018-11-23 11:32:54,933 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:54,934 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:54,934 INFO L74 IsIncluded]: Start isIncluded. First operand 169 states. Second operand 184 states. [2018-11-23 11:32:54,934 INFO L87 Difference]: Start difference. First operand 169 states. Second operand 184 states. [2018-11-23 11:32:54,945 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:32:54,945 INFO L93 Difference]: Finished difference Result 184 states and 279 transitions. [2018-11-23 11:32:54,945 INFO L276 IsEmpty]: Start isEmpty. Operand 184 states and 279 transitions. [2018-11-23 11:32:54,947 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:32:54,947 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:32:54,947 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 11:32:54,947 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 11:32:54,947 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 169 states. [2018-11-23 11:32:54,956 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 169 states to 169 states and 261 transitions. [2018-11-23 11:32:54,957 INFO L78 Accepts]: Start accepts. Automaton has 169 states and 261 transitions. Word has length 66 [2018-11-23 11:32:54,957 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 11:32:54,957 INFO L480 AbstractCegarLoop]: Abstraction has 169 states and 261 transitions. [2018-11-23 11:32:54,957 INFO L481 AbstractCegarLoop]: Interpolant automaton has 9 states. [2018-11-23 11:32:54,957 INFO L276 IsEmpty]: Start isEmpty. Operand 169 states and 261 transitions. [2018-11-23 11:32:54,959 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 80 [2018-11-23 11:32:54,959 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 11:32:54,959 INFO L402 BasicCegarLoop]: trace histogram [13, 12, 12, 2, 2, 2, 2, 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] [2018-11-23 11:32:54,959 INFO L423 AbstractCegarLoop]: === Iteration 9 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 11:32:54,960 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 11:32:54,960 INFO L82 PathProgramCache]: Analyzing trace with hash -328806665, now seen corresponding path program 1 times [2018-11-23 11:32:54,960 INFO L223 ckRefinementStrategy]: Switched to mode CVC4_FPBP [2018-11-23 11:32:54,960 INFO L69 tionRefinementEngine]: Using refinement strategy WolfRefinementStrategy No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/cvc4nyu Starting monitored process 10 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 10 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk [2018-11-23 11:32:54,994 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 11:32:55,061 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:55,080 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:32:55,082 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 11:32:55,373 INFO L256 TraceCheckUtils]: 0: Hoare triple {5356#true} call ULTIMATE.init(); {5356#true} is VALID [2018-11-23 11:32:55,373 INFO L273 TraceCheckUtils]: 1: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,373 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {5356#true} {5356#true} #77#return; {5356#true} is VALID [2018-11-23 11:32:55,373 INFO L256 TraceCheckUtils]: 3: Hoare triple {5356#true} call #t~ret11 := main(); {5356#true} is VALID [2018-11-23 11:32:55,374 INFO L273 TraceCheckUtils]: 4: Hoare triple {5356#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {5356#true} is VALID [2018-11-23 11:32:55,374 INFO L273 TraceCheckUtils]: 5: Hoare triple {5356#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {5376#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:32:55,374 INFO L273 TraceCheckUtils]: 6: Hoare triple {5376#(= main_~i~0 (_ bv0 32))} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {5380#(and (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} is VALID [2018-11-23 11:32:55,375 INFO L273 TraceCheckUtils]: 7: Hoare triple {5380#(and (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {5380#(and (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} is VALID [2018-11-23 11:32:55,375 INFO L273 TraceCheckUtils]: 8: Hoare triple {5380#(and (= main_~i~0 (_ bv0 32)) (bvslt main_~i~0 main_~len~0))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:55,375 INFO L256 TraceCheckUtils]: 9: Hoare triple {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,376 INFO L273 TraceCheckUtils]: 10: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,376 INFO L273 TraceCheckUtils]: 11: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,376 INFO L273 TraceCheckUtils]: 12: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,377 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {5356#true} {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #81#return; {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:55,377 INFO L256 TraceCheckUtils]: 14: Hoare triple {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,377 INFO L273 TraceCheckUtils]: 15: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,377 INFO L273 TraceCheckUtils]: 16: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,377 INFO L273 TraceCheckUtils]: 17: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,378 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {5356#true} {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #83#return; {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:55,379 INFO L273 TraceCheckUtils]: 19: Hoare triple {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} assume 0bv32 != #t~nondet3;havoc #t~nondet3; {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:55,379 INFO L256 TraceCheckUtils]: 20: Hoare triple {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,379 INFO L273 TraceCheckUtils]: 21: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,380 INFO L273 TraceCheckUtils]: 22: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,380 INFO L273 TraceCheckUtils]: 23: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,380 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {5356#true} {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #105#return; {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:55,381 INFO L256 TraceCheckUtils]: 25: Hoare triple {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,381 INFO L273 TraceCheckUtils]: 26: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,381 INFO L273 TraceCheckUtils]: 27: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,381 INFO L273 TraceCheckUtils]: 28: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,390 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {5356#true} {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #107#return; {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:55,390 INFO L256 TraceCheckUtils]: 30: Hoare triple {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,390 INFO L273 TraceCheckUtils]: 31: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,390 INFO L273 TraceCheckUtils]: 32: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,391 INFO L273 TraceCheckUtils]: 33: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,392 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {5356#true} {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #109#return; {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:55,392 INFO L256 TraceCheckUtils]: 35: Hoare triple {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,392 INFO L273 TraceCheckUtils]: 36: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,392 INFO L273 TraceCheckUtils]: 37: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,392 INFO L273 TraceCheckUtils]: 38: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,410 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {5356#true} {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #111#return; {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} is VALID [2018-11-23 11:32:55,425 INFO L273 TraceCheckUtils]: 40: Hoare triple {5387#(and (= main_~i~0 (_ bv0 32)) (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0))} #t~post9 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post9);havoc #t~post9;#t~post10 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post10);havoc #t~post10; {5484#(and (bvslt main_~i~0 main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:55,435 INFO L273 TraceCheckUtils]: 41: Hoare triple {5484#(and (bvslt main_~i~0 main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {5484#(and (bvslt main_~i~0 main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:55,435 INFO L273 TraceCheckUtils]: 42: Hoare triple {5484#(and (bvslt main_~i~0 main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:55,436 INFO L256 TraceCheckUtils]: 43: Hoare triple {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,436 INFO L273 TraceCheckUtils]: 44: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,436 INFO L273 TraceCheckUtils]: 45: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,436 INFO L273 TraceCheckUtils]: 46: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,437 INFO L268 TraceCheckUtils]: 47: Hoare quadruple {5356#true} {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} #81#return; {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:55,437 INFO L256 TraceCheckUtils]: 48: Hoare triple {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,437 INFO L273 TraceCheckUtils]: 49: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,437 INFO L273 TraceCheckUtils]: 50: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,438 INFO L273 TraceCheckUtils]: 51: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,438 INFO L268 TraceCheckUtils]: 52: Hoare quadruple {5356#true} {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} #83#return; {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:55,439 INFO L273 TraceCheckUtils]: 53: Hoare triple {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:55,439 INFO L256 TraceCheckUtils]: 54: Hoare triple {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,439 INFO L273 TraceCheckUtils]: 55: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,439 INFO L273 TraceCheckUtils]: 56: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,439 INFO L273 TraceCheckUtils]: 57: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,440 INFO L268 TraceCheckUtils]: 58: Hoare quadruple {5356#true} {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} #85#return; {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:55,440 INFO L256 TraceCheckUtils]: 59: Hoare triple {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,440 INFO L273 TraceCheckUtils]: 60: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,440 INFO L273 TraceCheckUtils]: 61: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,440 INFO L273 TraceCheckUtils]: 62: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,441 INFO L268 TraceCheckUtils]: 63: Hoare quadruple {5356#true} {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} #87#return; {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:55,441 INFO L256 TraceCheckUtils]: 64: Hoare triple {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,441 INFO L273 TraceCheckUtils]: 65: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,441 INFO L273 TraceCheckUtils]: 66: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,442 INFO L273 TraceCheckUtils]: 67: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,446 INFO L268 TraceCheckUtils]: 68: Hoare quadruple {5356#true} {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} #89#return; {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:55,446 INFO L256 TraceCheckUtils]: 69: Hoare triple {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,446 INFO L273 TraceCheckUtils]: 70: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,446 INFO L273 TraceCheckUtils]: 71: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,447 INFO L273 TraceCheckUtils]: 72: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,456 INFO L268 TraceCheckUtils]: 73: Hoare quadruple {5356#true} {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} #91#return; {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:32:55,457 INFO L273 TraceCheckUtils]: 74: Hoare triple {5491#(and (bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0) (= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32)))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {5588#(and (bvslt main_~i~0 main_~len~0) (= (_ bv2 32) main_~i~0))} is VALID [2018-11-23 11:32:55,459 INFO L256 TraceCheckUtils]: 75: Hoare triple {5588#(and (bvslt main_~i~0 main_~len~0) (= (_ bv2 32) main_~i~0))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {5592#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:55,459 INFO L273 TraceCheckUtils]: 76: Hoare triple {5592#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} ~cond := #in~cond; {5596#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:32:55,464 INFO L273 TraceCheckUtils]: 77: Hoare triple {5596#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} assume 0bv32 == ~cond; {5357#false} is VALID [2018-11-23 11:32:55,464 INFO L273 TraceCheckUtils]: 78: Hoare triple {5357#false} assume !false; {5357#false} is VALID [2018-11-23 11:32:55,470 INFO L134 CoverageAnalysis]: Checked inductivity of 293 backedges. 24 proven. 5 refuted. 0 times theorem prover too weak. 264 trivial. 0 not checked. [2018-11-23 11:32:55,470 INFO L316 TraceCheckSpWp]: Computing backward predicates... [2018-11-23 11:32:55,683 INFO L273 TraceCheckUtils]: 78: Hoare triple {5357#false} assume !false; {5357#false} is VALID [2018-11-23 11:32:55,684 INFO L273 TraceCheckUtils]: 77: Hoare triple {5606#(not (= (_ bv0 32) __VERIFIER_assert_~cond))} assume 0bv32 == ~cond; {5357#false} is VALID [2018-11-23 11:32:55,685 INFO L273 TraceCheckUtils]: 76: Hoare triple {5610#(not (= |__VERIFIER_assert_#in~cond| (_ bv0 32)))} ~cond := #in~cond; {5606#(not (= (_ bv0 32) __VERIFIER_assert_~cond))} is VALID [2018-11-23 11:32:55,687 INFO L256 TraceCheckUtils]: 75: Hoare triple {5614#(bvslt main_~i~0 main_~len~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {5610#(not (= |__VERIFIER_assert_#in~cond| (_ bv0 32)))} is VALID [2018-11-23 11:32:55,688 INFO L273 TraceCheckUtils]: 74: Hoare triple {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {5614#(bvslt main_~i~0 main_~len~0)} is VALID [2018-11-23 11:32:55,689 INFO L268 TraceCheckUtils]: 73: Hoare quadruple {5356#true} {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} #91#return; {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} is VALID [2018-11-23 11:32:55,689 INFO L273 TraceCheckUtils]: 72: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,690 INFO L273 TraceCheckUtils]: 71: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,690 INFO L273 TraceCheckUtils]: 70: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,690 INFO L256 TraceCheckUtils]: 69: Hoare triple {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,692 INFO L268 TraceCheckUtils]: 68: Hoare quadruple {5356#true} {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} #89#return; {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} is VALID [2018-11-23 11:32:55,692 INFO L273 TraceCheckUtils]: 67: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,692 INFO L273 TraceCheckUtils]: 66: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,693 INFO L273 TraceCheckUtils]: 65: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,693 INFO L256 TraceCheckUtils]: 64: Hoare triple {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,694 INFO L268 TraceCheckUtils]: 63: Hoare quadruple {5356#true} {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} #87#return; {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} is VALID [2018-11-23 11:32:55,694 INFO L273 TraceCheckUtils]: 62: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,695 INFO L273 TraceCheckUtils]: 61: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,695 INFO L273 TraceCheckUtils]: 60: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,695 INFO L256 TraceCheckUtils]: 59: Hoare triple {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,718 INFO L268 TraceCheckUtils]: 58: Hoare quadruple {5356#true} {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} #85#return; {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} is VALID [2018-11-23 11:32:55,718 INFO L273 TraceCheckUtils]: 57: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,719 INFO L273 TraceCheckUtils]: 56: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,719 INFO L273 TraceCheckUtils]: 55: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,719 INFO L256 TraceCheckUtils]: 54: Hoare triple {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,734 INFO L273 TraceCheckUtils]: 53: Hoare triple {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} is VALID [2018-11-23 11:32:55,744 INFO L268 TraceCheckUtils]: 52: Hoare quadruple {5356#true} {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} #83#return; {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} is VALID [2018-11-23 11:32:55,745 INFO L273 TraceCheckUtils]: 51: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,745 INFO L273 TraceCheckUtils]: 50: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,745 INFO L273 TraceCheckUtils]: 49: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,745 INFO L256 TraceCheckUtils]: 48: Hoare triple {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,747 INFO L268 TraceCheckUtils]: 47: Hoare quadruple {5356#true} {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} #81#return; {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} is VALID [2018-11-23 11:32:55,747 INFO L273 TraceCheckUtils]: 46: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,747 INFO L273 TraceCheckUtils]: 45: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,747 INFO L273 TraceCheckUtils]: 44: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,747 INFO L256 TraceCheckUtils]: 43: Hoare triple {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,748 INFO L273 TraceCheckUtils]: 42: Hoare triple {5356#true} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {5618#(bvslt (bvadd main_~i~0 (_ bv1 32)) main_~len~0)} is VALID [2018-11-23 11:32:55,748 INFO L273 TraceCheckUtils]: 41: Hoare triple {5356#true} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {5356#true} is VALID [2018-11-23 11:32:55,749 INFO L273 TraceCheckUtils]: 40: Hoare triple {5356#true} #t~post9 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post9);havoc #t~post9;#t~post10 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post10);havoc #t~post10; {5356#true} is VALID [2018-11-23 11:32:55,749 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {5356#true} {5356#true} #111#return; {5356#true} is VALID [2018-11-23 11:32:55,749 INFO L273 TraceCheckUtils]: 38: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,750 INFO L273 TraceCheckUtils]: 37: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,750 INFO L273 TraceCheckUtils]: 36: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,750 INFO L256 TraceCheckUtils]: 35: Hoare triple {5356#true} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,751 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {5356#true} {5356#true} #109#return; {5356#true} is VALID [2018-11-23 11:32:55,751 INFO L273 TraceCheckUtils]: 33: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,751 INFO L273 TraceCheckUtils]: 32: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,751 INFO L273 TraceCheckUtils]: 31: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,752 INFO L256 TraceCheckUtils]: 30: Hoare triple {5356#true} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,752 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {5356#true} {5356#true} #107#return; {5356#true} is VALID [2018-11-23 11:32:55,752 INFO L273 TraceCheckUtils]: 28: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,753 INFO L273 TraceCheckUtils]: 27: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,753 INFO L273 TraceCheckUtils]: 26: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,753 INFO L256 TraceCheckUtils]: 25: Hoare triple {5356#true} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,753 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {5356#true} {5356#true} #105#return; {5356#true} is VALID [2018-11-23 11:32:55,753 INFO L273 TraceCheckUtils]: 23: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,754 INFO L273 TraceCheckUtils]: 22: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,754 INFO L273 TraceCheckUtils]: 21: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,754 INFO L256 TraceCheckUtils]: 20: Hoare triple {5356#true} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,754 INFO L273 TraceCheckUtils]: 19: Hoare triple {5356#true} assume 0bv32 != #t~nondet3;havoc #t~nondet3; {5356#true} is VALID [2018-11-23 11:32:55,754 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {5356#true} {5356#true} #83#return; {5356#true} is VALID [2018-11-23 11:32:55,754 INFO L273 TraceCheckUtils]: 17: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,755 INFO L273 TraceCheckUtils]: 16: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,755 INFO L273 TraceCheckUtils]: 15: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,755 INFO L256 TraceCheckUtils]: 14: Hoare triple {5356#true} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,755 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {5356#true} {5356#true} #81#return; {5356#true} is VALID [2018-11-23 11:32:55,755 INFO L273 TraceCheckUtils]: 12: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,755 INFO L273 TraceCheckUtils]: 11: Hoare triple {5356#true} assume !(0bv32 == ~cond); {5356#true} is VALID [2018-11-23 11:32:55,756 INFO L273 TraceCheckUtils]: 10: Hoare triple {5356#true} ~cond := #in~cond; {5356#true} is VALID [2018-11-23 11:32:55,756 INFO L256 TraceCheckUtils]: 9: Hoare triple {5356#true} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {5356#true} is VALID [2018-11-23 11:32:55,756 INFO L273 TraceCheckUtils]: 8: Hoare triple {5356#true} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {5356#true} is VALID [2018-11-23 11:32:55,756 INFO L273 TraceCheckUtils]: 7: Hoare triple {5356#true} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {5356#true} is VALID [2018-11-23 11:32:55,756 INFO L273 TraceCheckUtils]: 6: Hoare triple {5356#true} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {5356#true} is VALID [2018-11-23 11:32:55,757 INFO L273 TraceCheckUtils]: 5: Hoare triple {5356#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {5356#true} is VALID [2018-11-23 11:32:55,757 INFO L273 TraceCheckUtils]: 4: Hoare triple {5356#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {5356#true} is VALID [2018-11-23 11:32:55,757 INFO L256 TraceCheckUtils]: 3: Hoare triple {5356#true} call #t~ret11 := main(); {5356#true} is VALID [2018-11-23 11:32:55,757 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {5356#true} {5356#true} #77#return; {5356#true} is VALID [2018-11-23 11:32:55,757 INFO L273 TraceCheckUtils]: 1: Hoare triple {5356#true} assume true; {5356#true} is VALID [2018-11-23 11:32:55,757 INFO L256 TraceCheckUtils]: 0: Hoare triple {5356#true} call ULTIMATE.init(); {5356#true} is VALID [2018-11-23 11:32:55,764 INFO L134 CoverageAnalysis]: Checked inductivity of 293 backedges. 27 proven. 0 refuted. 0 times theorem prover too weak. 266 trivial. 0 not checked. [2018-11-23 11:32:55,767 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 1 imperfect interpolant sequences. [2018-11-23 11:32:55,767 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [6] imperfect sequences [10] total 14 [2018-11-23 11:32:55,767 INFO L78 Accepts]: Start accepts. Automaton has 14 states. Word has length 79 [2018-11-23 11:32:55,768 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 11:32:55,768 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 14 states. [2018-11-23 11:32:55,918 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 82 edges. 82 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:32:55,919 INFO L459 AbstractCegarLoop]: Interpolant automaton has 14 states [2018-11-23 11:32:55,919 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 14 interpolants. [2018-11-23 11:32:55,919 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=38, Invalid=144, Unknown=0, NotChecked=0, Total=182 [2018-11-23 11:32:55,920 INFO L87 Difference]: Start difference. First operand 169 states and 261 transitions. Second operand 14 states. [2018-11-23 11:33:00,654 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:33:00,654 INFO L93 Difference]: Finished difference Result 251 states and 401 transitions. [2018-11-23 11:33:00,654 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 14 states. [2018-11-23 11:33:00,654 INFO L78 Accepts]: Start accepts. Automaton has 14 states. Word has length 79 [2018-11-23 11:33:00,655 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 11:33:00,655 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 14 states. [2018-11-23 11:33:00,660 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 14 states to 14 states and 176 transitions. [2018-11-23 11:33:00,660 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 14 states. [2018-11-23 11:33:00,664 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 14 states to 14 states and 176 transitions. [2018-11-23 11:33:00,665 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 14 states and 176 transitions. [2018-11-23 11:33:01,061 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 176 edges. 176 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:33:01,071 INFO L225 Difference]: With dead ends: 251 [2018-11-23 11:33:01,071 INFO L226 Difference]: Without dead ends: 247 [2018-11-23 11:33:01,072 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 162 GetRequests, 147 SyntacticMatches, 0 SemanticMatches, 15 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 44 ImplicationChecksByTransitivity, 0.3s TimeCoverageRelationStatistics Valid=56, Invalid=216, Unknown=0, NotChecked=0, Total=272 [2018-11-23 11:33:01,073 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 247 states. [2018-11-23 11:33:02,137 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 247 to 217. [2018-11-23 11:33:02,137 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 11:33:02,137 INFO L82 GeneralOperation]: Start isEquivalent. First operand 247 states. Second operand 217 states. [2018-11-23 11:33:02,137 INFO L74 IsIncluded]: Start isIncluded. First operand 247 states. Second operand 217 states. [2018-11-23 11:33:02,138 INFO L87 Difference]: Start difference. First operand 247 states. Second operand 217 states. [2018-11-23 11:33:02,164 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:33:02,164 INFO L93 Difference]: Finished difference Result 247 states and 393 transitions. [2018-11-23 11:33:02,164 INFO L276 IsEmpty]: Start isEmpty. Operand 247 states and 393 transitions. [2018-11-23 11:33:02,166 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:33:02,166 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:33:02,167 INFO L74 IsIncluded]: Start isIncluded. First operand 217 states. Second operand 247 states. [2018-11-23 11:33:02,167 INFO L87 Difference]: Start difference. First operand 217 states. Second operand 247 states. [2018-11-23 11:33:02,193 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:33:02,193 INFO L93 Difference]: Finished difference Result 247 states and 393 transitions. [2018-11-23 11:33:02,193 INFO L276 IsEmpty]: Start isEmpty. Operand 247 states and 393 transitions. [2018-11-23 11:33:02,195 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:33:02,196 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:33:02,196 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 11:33:02,196 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 11:33:02,196 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 217 states. [2018-11-23 11:33:02,210 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 217 states to 217 states and 344 transitions. [2018-11-23 11:33:02,211 INFO L78 Accepts]: Start accepts. Automaton has 217 states and 344 transitions. Word has length 79 [2018-11-23 11:33:02,211 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 11:33:02,211 INFO L480 AbstractCegarLoop]: Abstraction has 217 states and 344 transitions. [2018-11-23 11:33:02,211 INFO L481 AbstractCegarLoop]: Interpolant automaton has 14 states. [2018-11-23 11:33:02,211 INFO L276 IsEmpty]: Start isEmpty. Operand 217 states and 344 transitions. [2018-11-23 11:33:02,213 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 85 [2018-11-23 11:33:02,213 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 11:33:02,213 INFO L402 BasicCegarLoop]: trace histogram [14, 13, 13, 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] [2018-11-23 11:33:02,213 INFO L423 AbstractCegarLoop]: === Iteration 10 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 11:33:02,214 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 11:33:02,214 INFO L82 PathProgramCache]: Analyzing trace with hash -1373065331, now seen corresponding path program 1 times [2018-11-23 11:33:02,214 INFO L223 ckRefinementStrategy]: Switched to mode CVC4_FPBP [2018-11-23 11:33:02,214 INFO L69 tionRefinementEngine]: Using refinement strategy WolfRefinementStrategy No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/cvc4nyu Starting monitored process 11 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 11 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk [2018-11-23 11:33:02,239 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 11:33:02,303 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:33:02,346 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:33:02,348 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 11:33:02,484 INFO L256 TraceCheckUtils]: 0: Hoare triple {7126#true} call ULTIMATE.init(); {7126#true} is VALID [2018-11-23 11:33:02,484 INFO L273 TraceCheckUtils]: 1: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,484 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {7126#true} {7126#true} #77#return; {7126#true} is VALID [2018-11-23 11:33:02,485 INFO L256 TraceCheckUtils]: 3: Hoare triple {7126#true} call #t~ret11 := main(); {7126#true} is VALID [2018-11-23 11:33:02,485 INFO L273 TraceCheckUtils]: 4: Hoare triple {7126#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {7126#true} is VALID [2018-11-23 11:33:02,491 INFO L273 TraceCheckUtils]: 5: Hoare triple {7126#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {7146#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:33:02,492 INFO L273 TraceCheckUtils]: 6: Hoare triple {7146#(= main_~i~0 (_ bv0 32))} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {7146#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:33:02,492 INFO L273 TraceCheckUtils]: 7: Hoare triple {7146#(= main_~i~0 (_ bv0 32))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {7146#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:33:02,492 INFO L273 TraceCheckUtils]: 8: Hoare triple {7146#(= main_~i~0 (_ bv0 32))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {7146#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:33:02,493 INFO L256 TraceCheckUtils]: 9: Hoare triple {7146#(= main_~i~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,493 INFO L273 TraceCheckUtils]: 10: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,493 INFO L273 TraceCheckUtils]: 11: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,493 INFO L273 TraceCheckUtils]: 12: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,494 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {7126#true} {7146#(= main_~i~0 (_ bv0 32))} #81#return; {7146#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:33:02,494 INFO L256 TraceCheckUtils]: 14: Hoare triple {7146#(= main_~i~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,494 INFO L273 TraceCheckUtils]: 15: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,494 INFO L273 TraceCheckUtils]: 16: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,494 INFO L273 TraceCheckUtils]: 17: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,495 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {7126#true} {7146#(= main_~i~0 (_ bv0 32))} #83#return; {7146#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:33:02,495 INFO L273 TraceCheckUtils]: 19: Hoare triple {7146#(= main_~i~0 (_ bv0 32))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {7146#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:33:02,495 INFO L256 TraceCheckUtils]: 20: Hoare triple {7146#(= main_~i~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,496 INFO L273 TraceCheckUtils]: 21: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,496 INFO L273 TraceCheckUtils]: 22: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,496 INFO L273 TraceCheckUtils]: 23: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,497 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {7126#true} {7146#(= main_~i~0 (_ bv0 32))} #85#return; {7146#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:33:02,497 INFO L256 TraceCheckUtils]: 25: Hoare triple {7146#(= main_~i~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,498 INFO L273 TraceCheckUtils]: 26: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,498 INFO L273 TraceCheckUtils]: 27: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,498 INFO L273 TraceCheckUtils]: 28: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,502 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {7126#true} {7146#(= main_~i~0 (_ bv0 32))} #87#return; {7146#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:33:02,502 INFO L256 TraceCheckUtils]: 30: Hoare triple {7146#(= main_~i~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,502 INFO L273 TraceCheckUtils]: 31: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,503 INFO L273 TraceCheckUtils]: 32: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,503 INFO L273 TraceCheckUtils]: 33: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,504 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {7126#true} {7146#(= main_~i~0 (_ bv0 32))} #89#return; {7146#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:33:02,504 INFO L256 TraceCheckUtils]: 35: Hoare triple {7146#(= main_~i~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,504 INFO L273 TraceCheckUtils]: 36: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,504 INFO L273 TraceCheckUtils]: 37: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,504 INFO L273 TraceCheckUtils]: 38: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,520 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {7126#true} {7146#(= main_~i~0 (_ bv0 32))} #91#return; {7146#(= main_~i~0 (_ bv0 32))} is VALID [2018-11-23 11:33:02,521 INFO L273 TraceCheckUtils]: 40: Hoare triple {7146#(= main_~i~0 (_ bv0 32))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {7252#(= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:02,521 INFO L256 TraceCheckUtils]: 41: Hoare triple {7252#(= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,521 INFO L273 TraceCheckUtils]: 42: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,521 INFO L273 TraceCheckUtils]: 43: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,521 INFO L273 TraceCheckUtils]: 44: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,523 INFO L268 TraceCheckUtils]: 45: Hoare quadruple {7126#true} {7252#(= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32))} #93#return; {7252#(= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:02,523 INFO L256 TraceCheckUtils]: 46: Hoare triple {7252#(= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,523 INFO L273 TraceCheckUtils]: 47: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,523 INFO L273 TraceCheckUtils]: 48: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,523 INFO L273 TraceCheckUtils]: 49: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,524 INFO L268 TraceCheckUtils]: 50: Hoare quadruple {7126#true} {7252#(= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32))} #95#return; {7252#(= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:02,524 INFO L256 TraceCheckUtils]: 51: Hoare triple {7252#(= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,524 INFO L273 TraceCheckUtils]: 52: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,524 INFO L273 TraceCheckUtils]: 53: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,524 INFO L273 TraceCheckUtils]: 54: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,525 INFO L268 TraceCheckUtils]: 55: Hoare quadruple {7126#true} {7252#(= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32))} #97#return; {7252#(= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:02,525 INFO L256 TraceCheckUtils]: 56: Hoare triple {7252#(= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,525 INFO L273 TraceCheckUtils]: 57: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,525 INFO L273 TraceCheckUtils]: 58: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,525 INFO L273 TraceCheckUtils]: 59: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,526 INFO L268 TraceCheckUtils]: 60: Hoare quadruple {7126#true} {7252#(= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32))} #99#return; {7252#(= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:02,527 INFO L273 TraceCheckUtils]: 61: Hoare triple {7252#(= (bvadd main_~i~0 (_ bv4294967295 32)) (_ bv0 32))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {7316#(= (_ bv2 32) main_~i~0)} is VALID [2018-11-23 11:33:02,527 INFO L256 TraceCheckUtils]: 62: Hoare triple {7316#(= (_ bv2 32) main_~i~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,527 INFO L273 TraceCheckUtils]: 63: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,527 INFO L273 TraceCheckUtils]: 64: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,527 INFO L273 TraceCheckUtils]: 65: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,528 INFO L268 TraceCheckUtils]: 66: Hoare quadruple {7126#true} {7316#(= (_ bv2 32) main_~i~0)} #101#return; {7316#(= (_ bv2 32) main_~i~0)} is VALID [2018-11-23 11:33:02,528 INFO L256 TraceCheckUtils]: 67: Hoare triple {7316#(= (_ bv2 32) main_~i~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,528 INFO L273 TraceCheckUtils]: 68: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,528 INFO L273 TraceCheckUtils]: 69: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,528 INFO L273 TraceCheckUtils]: 70: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,529 INFO L268 TraceCheckUtils]: 71: Hoare quadruple {7126#true} {7316#(= (_ bv2 32) main_~i~0)} #103#return; {7316#(= (_ bv2 32) main_~i~0)} is VALID [2018-11-23 11:33:02,529 INFO L273 TraceCheckUtils]: 72: Hoare triple {7316#(= (_ bv2 32) main_~i~0)} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {7316#(= (_ bv2 32) main_~i~0)} is VALID [2018-11-23 11:33:02,530 INFO L273 TraceCheckUtils]: 73: Hoare triple {7316#(= (_ bv2 32) main_~i~0)} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {7316#(= (_ bv2 32) main_~i~0)} is VALID [2018-11-23 11:33:02,530 INFO L273 TraceCheckUtils]: 74: Hoare triple {7316#(= (_ bv2 32) main_~i~0)} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {7316#(= (_ bv2 32) main_~i~0)} is VALID [2018-11-23 11:33:02,530 INFO L256 TraceCheckUtils]: 75: Hoare triple {7316#(= (_ bv2 32) main_~i~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,531 INFO L273 TraceCheckUtils]: 76: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,531 INFO L273 TraceCheckUtils]: 77: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,531 INFO L273 TraceCheckUtils]: 78: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,532 INFO L268 TraceCheckUtils]: 79: Hoare quadruple {7126#true} {7316#(= (_ bv2 32) main_~i~0)} #105#return; {7316#(= (_ bv2 32) main_~i~0)} is VALID [2018-11-23 11:33:02,533 INFO L256 TraceCheckUtils]: 80: Hoare triple {7316#(= (_ bv2 32) main_~i~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {7374#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:02,534 INFO L273 TraceCheckUtils]: 81: Hoare triple {7374#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} ~cond := #in~cond; {7378#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:02,534 INFO L273 TraceCheckUtils]: 82: Hoare triple {7378#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} assume 0bv32 == ~cond; {7127#false} is VALID [2018-11-23 11:33:02,535 INFO L273 TraceCheckUtils]: 83: Hoare triple {7127#false} assume !false; {7127#false} is VALID [2018-11-23 11:33:02,539 INFO L134 CoverageAnalysis]: Checked inductivity of 340 backedges. 26 proven. 2 refuted. 0 times theorem prover too weak. 312 trivial. 0 not checked. [2018-11-23 11:33:02,540 INFO L316 TraceCheckSpWp]: Computing backward predicates... [2018-11-23 11:33:02,796 INFO L273 TraceCheckUtils]: 83: Hoare triple {7127#false} assume !false; {7127#false} is VALID [2018-11-23 11:33:02,797 INFO L273 TraceCheckUtils]: 82: Hoare triple {7388#(not (= (_ bv0 32) __VERIFIER_assert_~cond))} assume 0bv32 == ~cond; {7127#false} is VALID [2018-11-23 11:33:02,797 INFO L273 TraceCheckUtils]: 81: Hoare triple {7392#(not (= |__VERIFIER_assert_#in~cond| (_ bv0 32)))} ~cond := #in~cond; {7388#(not (= (_ bv0 32) __VERIFIER_assert_~cond))} is VALID [2018-11-23 11:33:02,799 INFO L256 TraceCheckUtils]: 80: Hoare triple {7396#(bvsle (_ bv0 32) main_~i~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {7392#(not (= |__VERIFIER_assert_#in~cond| (_ bv0 32)))} is VALID [2018-11-23 11:33:02,800 INFO L268 TraceCheckUtils]: 79: Hoare quadruple {7126#true} {7396#(bvsle (_ bv0 32) main_~i~0)} #105#return; {7396#(bvsle (_ bv0 32) main_~i~0)} is VALID [2018-11-23 11:33:02,800 INFO L273 TraceCheckUtils]: 78: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,800 INFO L273 TraceCheckUtils]: 77: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,800 INFO L273 TraceCheckUtils]: 76: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,801 INFO L256 TraceCheckUtils]: 75: Hoare triple {7396#(bvsle (_ bv0 32) main_~i~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,801 INFO L273 TraceCheckUtils]: 74: Hoare triple {7396#(bvsle (_ bv0 32) main_~i~0)} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {7396#(bvsle (_ bv0 32) main_~i~0)} is VALID [2018-11-23 11:33:02,802 INFO L273 TraceCheckUtils]: 73: Hoare triple {7396#(bvsle (_ bv0 32) main_~i~0)} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {7396#(bvsle (_ bv0 32) main_~i~0)} is VALID [2018-11-23 11:33:02,802 INFO L273 TraceCheckUtils]: 72: Hoare triple {7396#(bvsle (_ bv0 32) main_~i~0)} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {7396#(bvsle (_ bv0 32) main_~i~0)} is VALID [2018-11-23 11:33:02,803 INFO L268 TraceCheckUtils]: 71: Hoare quadruple {7126#true} {7396#(bvsle (_ bv0 32) main_~i~0)} #103#return; {7396#(bvsle (_ bv0 32) main_~i~0)} is VALID [2018-11-23 11:33:02,803 INFO L273 TraceCheckUtils]: 70: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,804 INFO L273 TraceCheckUtils]: 69: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,804 INFO L273 TraceCheckUtils]: 68: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,804 INFO L256 TraceCheckUtils]: 67: Hoare triple {7396#(bvsle (_ bv0 32) main_~i~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,805 INFO L268 TraceCheckUtils]: 66: Hoare quadruple {7126#true} {7396#(bvsle (_ bv0 32) main_~i~0)} #101#return; {7396#(bvsle (_ bv0 32) main_~i~0)} is VALID [2018-11-23 11:33:02,805 INFO L273 TraceCheckUtils]: 65: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,806 INFO L273 TraceCheckUtils]: 64: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,806 INFO L273 TraceCheckUtils]: 63: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,806 INFO L256 TraceCheckUtils]: 62: Hoare triple {7396#(bvsle (_ bv0 32) main_~i~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,807 INFO L273 TraceCheckUtils]: 61: Hoare triple {7454#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv1 32)))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {7396#(bvsle (_ bv0 32) main_~i~0)} is VALID [2018-11-23 11:33:02,808 INFO L268 TraceCheckUtils]: 60: Hoare quadruple {7126#true} {7454#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv1 32)))} #99#return; {7454#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:02,808 INFO L273 TraceCheckUtils]: 59: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,808 INFO L273 TraceCheckUtils]: 58: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,809 INFO L273 TraceCheckUtils]: 57: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,809 INFO L256 TraceCheckUtils]: 56: Hoare triple {7454#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv1 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,810 INFO L268 TraceCheckUtils]: 55: Hoare quadruple {7126#true} {7454#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv1 32)))} #97#return; {7454#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:02,810 INFO L273 TraceCheckUtils]: 54: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,810 INFO L273 TraceCheckUtils]: 53: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,810 INFO L273 TraceCheckUtils]: 52: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,811 INFO L256 TraceCheckUtils]: 51: Hoare triple {7454#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv1 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,811 INFO L268 TraceCheckUtils]: 50: Hoare quadruple {7126#true} {7454#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv1 32)))} #95#return; {7454#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:02,811 INFO L273 TraceCheckUtils]: 49: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,812 INFO L273 TraceCheckUtils]: 48: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,812 INFO L273 TraceCheckUtils]: 47: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,812 INFO L256 TraceCheckUtils]: 46: Hoare triple {7454#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv1 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,812 INFO L268 TraceCheckUtils]: 45: Hoare quadruple {7126#true} {7454#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv1 32)))} #93#return; {7454#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:02,812 INFO L273 TraceCheckUtils]: 44: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,813 INFO L273 TraceCheckUtils]: 43: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,813 INFO L273 TraceCheckUtils]: 42: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,813 INFO L256 TraceCheckUtils]: 41: Hoare triple {7454#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv1 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,816 INFO L273 TraceCheckUtils]: 40: Hoare triple {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {7454#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:02,817 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {7126#true} {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} #91#return; {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:02,817 INFO L273 TraceCheckUtils]: 38: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,818 INFO L273 TraceCheckUtils]: 37: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,818 INFO L273 TraceCheckUtils]: 36: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,818 INFO L256 TraceCheckUtils]: 35: Hoare triple {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,819 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {7126#true} {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} #89#return; {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:02,819 INFO L273 TraceCheckUtils]: 33: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,819 INFO L273 TraceCheckUtils]: 32: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,819 INFO L273 TraceCheckUtils]: 31: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,819 INFO L256 TraceCheckUtils]: 30: Hoare triple {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,825 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {7126#true} {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} #87#return; {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:02,826 INFO L273 TraceCheckUtils]: 28: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,826 INFO L273 TraceCheckUtils]: 27: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,826 INFO L273 TraceCheckUtils]: 26: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,826 INFO L256 TraceCheckUtils]: 25: Hoare triple {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,827 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {7126#true} {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} #85#return; {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:02,827 INFO L273 TraceCheckUtils]: 23: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,827 INFO L273 TraceCheckUtils]: 22: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,827 INFO L273 TraceCheckUtils]: 21: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,828 INFO L256 TraceCheckUtils]: 20: Hoare triple {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,828 INFO L273 TraceCheckUtils]: 19: Hoare triple {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:02,828 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {7126#true} {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} #83#return; {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:02,829 INFO L273 TraceCheckUtils]: 17: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,829 INFO L273 TraceCheckUtils]: 16: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,829 INFO L273 TraceCheckUtils]: 15: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,829 INFO L256 TraceCheckUtils]: 14: Hoare triple {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,829 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {7126#true} {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} #81#return; {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:02,830 INFO L273 TraceCheckUtils]: 12: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,830 INFO L273 TraceCheckUtils]: 11: Hoare triple {7126#true} assume !(0bv32 == ~cond); {7126#true} is VALID [2018-11-23 11:33:02,830 INFO L273 TraceCheckUtils]: 10: Hoare triple {7126#true} ~cond := #in~cond; {7126#true} is VALID [2018-11-23 11:33:02,830 INFO L256 TraceCheckUtils]: 9: Hoare triple {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {7126#true} is VALID [2018-11-23 11:33:02,830 INFO L273 TraceCheckUtils]: 8: Hoare triple {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:02,831 INFO L273 TraceCheckUtils]: 7: Hoare triple {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:02,831 INFO L273 TraceCheckUtils]: 6: Hoare triple {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:02,831 INFO L273 TraceCheckUtils]: 5: Hoare triple {7126#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {7518#(bvsle (_ bv0 32) (bvadd main_~i~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:02,832 INFO L273 TraceCheckUtils]: 4: Hoare triple {7126#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {7126#true} is VALID [2018-11-23 11:33:02,832 INFO L256 TraceCheckUtils]: 3: Hoare triple {7126#true} call #t~ret11 := main(); {7126#true} is VALID [2018-11-23 11:33:02,832 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {7126#true} {7126#true} #77#return; {7126#true} is VALID [2018-11-23 11:33:02,832 INFO L273 TraceCheckUtils]: 1: Hoare triple {7126#true} assume true; {7126#true} is VALID [2018-11-23 11:33:02,832 INFO L256 TraceCheckUtils]: 0: Hoare triple {7126#true} call ULTIMATE.init(); {7126#true} is VALID [2018-11-23 11:33:02,836 INFO L134 CoverageAnalysis]: Checked inductivity of 340 backedges. 26 proven. 2 refuted. 0 times theorem prover too weak. 312 trivial. 0 not checked. [2018-11-23 11:33:02,839 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 11:33:02,839 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [7, 7] total 12 [2018-11-23 11:33:02,840 INFO L78 Accepts]: Start accepts. Automaton has 12 states. Word has length 84 [2018-11-23 11:33:02,840 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 11:33:02,841 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 12 states. [2018-11-23 11:33:02,994 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 87 edges. 87 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:33:02,994 INFO L459 AbstractCegarLoop]: Interpolant automaton has 12 states [2018-11-23 11:33:02,994 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 12 interpolants. [2018-11-23 11:33:02,995 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=32, Invalid=100, Unknown=0, NotChecked=0, Total=132 [2018-11-23 11:33:02,995 INFO L87 Difference]: Start difference. First operand 217 states and 344 transitions. Second operand 12 states. [2018-11-23 11:33:07,454 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:33:07,454 INFO L93 Difference]: Finished difference Result 331 states and 534 transitions. [2018-11-23 11:33:07,454 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 11 states. [2018-11-23 11:33:07,454 INFO L78 Accepts]: Start accepts. Automaton has 12 states. Word has length 84 [2018-11-23 11:33:07,454 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 11:33:07,455 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 12 states. [2018-11-23 11:33:07,459 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 11 states to 11 states and 201 transitions. [2018-11-23 11:33:07,460 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 12 states. [2018-11-23 11:33:07,464 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 11 states to 11 states and 201 transitions. [2018-11-23 11:33:07,464 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 11 states and 201 transitions. [2018-11-23 11:33:07,814 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 201 edges. 201 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:33:07,825 INFO L225 Difference]: With dead ends: 331 [2018-11-23 11:33:07,825 INFO L226 Difference]: Without dead ends: 323 [2018-11-23 11:33:07,826 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 170 GetRequests, 157 SyntacticMatches, 0 SemanticMatches, 13 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 10 ImplicationChecksByTransitivity, 0.1s TimeCoverageRelationStatistics Valid=54, Invalid=156, Unknown=0, NotChecked=0, Total=210 [2018-11-23 11:33:07,826 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 323 states. [2018-11-23 11:33:08,342 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 323 to 227. [2018-11-23 11:33:08,342 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 11:33:08,342 INFO L82 GeneralOperation]: Start isEquivalent. First operand 323 states. Second operand 227 states. [2018-11-23 11:33:08,342 INFO L74 IsIncluded]: Start isIncluded. First operand 323 states. Second operand 227 states. [2018-11-23 11:33:08,342 INFO L87 Difference]: Start difference. First operand 323 states. Second operand 227 states. [2018-11-23 11:33:08,358 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:33:08,358 INFO L93 Difference]: Finished difference Result 323 states and 516 transitions. [2018-11-23 11:33:08,359 INFO L276 IsEmpty]: Start isEmpty. Operand 323 states and 516 transitions. [2018-11-23 11:33:08,361 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:33:08,361 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:33:08,362 INFO L74 IsIncluded]: Start isIncluded. First operand 227 states. Second operand 323 states. [2018-11-23 11:33:08,362 INFO L87 Difference]: Start difference. First operand 227 states. Second operand 323 states. [2018-11-23 11:33:08,379 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:33:08,379 INFO L93 Difference]: Finished difference Result 323 states and 516 transitions. [2018-11-23 11:33:08,379 INFO L276 IsEmpty]: Start isEmpty. Operand 323 states and 516 transitions. [2018-11-23 11:33:08,382 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:33:08,383 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:33:08,383 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 11:33:08,383 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 11:33:08,383 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 227 states. [2018-11-23 11:33:08,393 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 227 states to 227 states and 347 transitions. [2018-11-23 11:33:08,393 INFO L78 Accepts]: Start accepts. Automaton has 227 states and 347 transitions. Word has length 84 [2018-11-23 11:33:08,393 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 11:33:08,393 INFO L480 AbstractCegarLoop]: Abstraction has 227 states and 347 transitions. [2018-11-23 11:33:08,394 INFO L481 AbstractCegarLoop]: Interpolant automaton has 12 states. [2018-11-23 11:33:08,394 INFO L276 IsEmpty]: Start isEmpty. Operand 227 states and 347 transitions. [2018-11-23 11:33:08,395 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 90 [2018-11-23 11:33:08,395 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 11:33:08,395 INFO L402 BasicCegarLoop]: trace histogram [15, 14, 14, 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] [2018-11-23 11:33:08,396 INFO L423 AbstractCegarLoop]: === Iteration 11 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 11:33:08,396 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 11:33:08,396 INFO L82 PathProgramCache]: Analyzing trace with hash -1834661003, now seen corresponding path program 1 times [2018-11-23 11:33:08,396 INFO L223 ckRefinementStrategy]: Switched to mode CVC4_FPBP [2018-11-23 11:33:08,396 INFO L69 tionRefinementEngine]: Using refinement strategy WolfRefinementStrategy No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/cvc4nyu Starting monitored process 12 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 12 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk [2018-11-23 11:33:08,427 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 11:33:08,506 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:33:08,550 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:33:08,555 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 11:33:09,091 INFO L256 TraceCheckUtils]: 0: Hoare triple {9223#true} call ULTIMATE.init(); {9223#true} is VALID [2018-11-23 11:33:09,092 INFO L273 TraceCheckUtils]: 1: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,092 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {9223#true} {9223#true} #77#return; {9223#true} is VALID [2018-11-23 11:33:09,092 INFO L256 TraceCheckUtils]: 3: Hoare triple {9223#true} call #t~ret11 := main(); {9223#true} is VALID [2018-11-23 11:33:09,092 INFO L273 TraceCheckUtils]: 4: Hoare triple {9223#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {9223#true} is VALID [2018-11-23 11:33:09,093 INFO L273 TraceCheckUtils]: 5: Hoare triple {9223#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {9243#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} is VALID [2018-11-23 11:33:09,110 INFO L273 TraceCheckUtils]: 6: Hoare triple {9243#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {9247#(and (= main_~j~0 (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} is VALID [2018-11-23 11:33:09,117 INFO L273 TraceCheckUtils]: 7: Hoare triple {9247#(and (= main_~j~0 (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (= (bvadd main_~limit~0 (_ bv4 32)) main_~bufsize~0))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:33:09,118 INFO L273 TraceCheckUtils]: 8: Hoare triple {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:33:09,118 INFO L256 TraceCheckUtils]: 9: Hoare triple {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,118 INFO L273 TraceCheckUtils]: 10: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,118 INFO L273 TraceCheckUtils]: 11: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,118 INFO L273 TraceCheckUtils]: 12: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,119 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {9223#true} {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #81#return; {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:33:09,119 INFO L256 TraceCheckUtils]: 14: Hoare triple {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,119 INFO L273 TraceCheckUtils]: 15: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,119 INFO L273 TraceCheckUtils]: 16: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,119 INFO L273 TraceCheckUtils]: 17: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,120 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {9223#true} {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #83#return; {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:33:09,120 INFO L273 TraceCheckUtils]: 19: Hoare triple {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:33:09,120 INFO L256 TraceCheckUtils]: 20: Hoare triple {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,121 INFO L273 TraceCheckUtils]: 21: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,121 INFO L273 TraceCheckUtils]: 22: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,121 INFO L273 TraceCheckUtils]: 23: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,121 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {9223#true} {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #85#return; {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:33:09,122 INFO L256 TraceCheckUtils]: 25: Hoare triple {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,122 INFO L273 TraceCheckUtils]: 26: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,122 INFO L273 TraceCheckUtils]: 27: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,122 INFO L273 TraceCheckUtils]: 28: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,122 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {9223#true} {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #87#return; {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:33:09,123 INFO L256 TraceCheckUtils]: 30: Hoare triple {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,123 INFO L273 TraceCheckUtils]: 31: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,123 INFO L273 TraceCheckUtils]: 32: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,123 INFO L273 TraceCheckUtils]: 33: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,123 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {9223#true} {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #89#return; {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:33:09,123 INFO L256 TraceCheckUtils]: 35: Hoare triple {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,124 INFO L273 TraceCheckUtils]: 36: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,124 INFO L273 TraceCheckUtils]: 37: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,124 INFO L273 TraceCheckUtils]: 38: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,124 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {9223#true} {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #91#return; {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} is VALID [2018-11-23 11:33:09,126 INFO L273 TraceCheckUtils]: 40: Hoare triple {9251#(and (= main_~j~0 (_ bv0 32)) (bvslt main_~j~0 (bvadd main_~bufsize~0 (_ bv4294967292 32))) (not (bvslt main_~bufsize~0 (_ bv0 32))))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {9351#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:33:09,126 INFO L256 TraceCheckUtils]: 41: Hoare triple {9351#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,126 INFO L273 TraceCheckUtils]: 42: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,126 INFO L273 TraceCheckUtils]: 43: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,126 INFO L273 TraceCheckUtils]: 44: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,127 INFO L268 TraceCheckUtils]: 45: Hoare quadruple {9223#true} {9351#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} #93#return; {9351#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:33:09,127 INFO L256 TraceCheckUtils]: 46: Hoare triple {9351#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,127 INFO L273 TraceCheckUtils]: 47: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,127 INFO L273 TraceCheckUtils]: 48: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,128 INFO L273 TraceCheckUtils]: 49: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,128 INFO L268 TraceCheckUtils]: 50: Hoare quadruple {9223#true} {9351#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} #95#return; {9351#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:33:09,128 INFO L256 TraceCheckUtils]: 51: Hoare triple {9351#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,129 INFO L273 TraceCheckUtils]: 52: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,129 INFO L273 TraceCheckUtils]: 53: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,129 INFO L273 TraceCheckUtils]: 54: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,129 INFO L268 TraceCheckUtils]: 55: Hoare quadruple {9223#true} {9351#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} #97#return; {9351#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:33:09,130 INFO L256 TraceCheckUtils]: 56: Hoare triple {9351#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,130 INFO L273 TraceCheckUtils]: 57: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,130 INFO L273 TraceCheckUtils]: 58: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,130 INFO L273 TraceCheckUtils]: 59: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,130 INFO L268 TraceCheckUtils]: 60: Hoare quadruple {9223#true} {9351#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} #99#return; {9351#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} is VALID [2018-11-23 11:33:09,131 INFO L273 TraceCheckUtils]: 61: Hoare triple {9351#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967295 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32)))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {9415#(and (= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967294 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))))} is VALID [2018-11-23 11:33:09,131 INFO L256 TraceCheckUtils]: 62: Hoare triple {9415#(and (= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967294 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,131 INFO L273 TraceCheckUtils]: 63: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,132 INFO L273 TraceCheckUtils]: 64: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,132 INFO L273 TraceCheckUtils]: 65: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,133 INFO L268 TraceCheckUtils]: 66: Hoare quadruple {9223#true} {9415#(and (= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967294 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))))} #101#return; {9415#(and (= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967294 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))))} is VALID [2018-11-23 11:33:09,133 INFO L256 TraceCheckUtils]: 67: Hoare triple {9415#(and (= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967294 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,133 INFO L273 TraceCheckUtils]: 68: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,133 INFO L273 TraceCheckUtils]: 69: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,133 INFO L273 TraceCheckUtils]: 70: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,134 INFO L268 TraceCheckUtils]: 71: Hoare quadruple {9223#true} {9415#(and (= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967294 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))))} #103#return; {9415#(and (= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967294 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))))} is VALID [2018-11-23 11:33:09,135 INFO L273 TraceCheckUtils]: 72: Hoare triple {9415#(and (= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32)) (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967294 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {9449#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967293 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32)))} is VALID [2018-11-23 11:33:09,136 INFO L273 TraceCheckUtils]: 73: Hoare triple {9449#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967293 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {9449#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967293 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32)))} is VALID [2018-11-23 11:33:09,136 INFO L273 TraceCheckUtils]: 74: Hoare triple {9449#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967293 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32)))} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {9449#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967293 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32)))} is VALID [2018-11-23 11:33:09,136 INFO L256 TraceCheckUtils]: 75: Hoare triple {9449#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967293 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,136 INFO L273 TraceCheckUtils]: 76: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,136 INFO L273 TraceCheckUtils]: 77: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,137 INFO L273 TraceCheckUtils]: 78: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,137 INFO L268 TraceCheckUtils]: 79: Hoare quadruple {9223#true} {9449#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967293 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32)))} #105#return; {9449#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967293 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32)))} is VALID [2018-11-23 11:33:09,137 INFO L256 TraceCheckUtils]: 80: Hoare triple {9449#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967293 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,138 INFO L273 TraceCheckUtils]: 81: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,138 INFO L273 TraceCheckUtils]: 82: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,138 INFO L273 TraceCheckUtils]: 83: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,139 INFO L268 TraceCheckUtils]: 84: Hoare quadruple {9223#true} {9449#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967293 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32)))} #107#return; {9449#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967293 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32)))} is VALID [2018-11-23 11:33:09,140 INFO L256 TraceCheckUtils]: 85: Hoare triple {9449#(and (not (bvslt main_~bufsize~0 (_ bv0 32))) (bvslt (bvadd main_~j~0 (_ bv4294967293 32)) (bvadd main_~bufsize~0 (_ bv4294967292 32))) (= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {9489#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:09,141 INFO L273 TraceCheckUtils]: 86: Hoare triple {9489#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} ~cond := #in~cond; {9493#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:09,141 INFO L273 TraceCheckUtils]: 87: Hoare triple {9493#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} assume 0bv32 == ~cond; {9224#false} is VALID [2018-11-23 11:33:09,141 INFO L273 TraceCheckUtils]: 88: Hoare triple {9224#false} assume !false; {9224#false} is VALID [2018-11-23 11:33:09,151 INFO L134 CoverageAnalysis]: Checked inductivity of 394 backedges. 28 proven. 2 refuted. 0 times theorem prover too weak. 364 trivial. 0 not checked. [2018-11-23 11:33:09,151 INFO L316 TraceCheckSpWp]: Computing backward predicates... [2018-11-23 11:33:09,716 INFO L273 TraceCheckUtils]: 88: Hoare triple {9224#false} assume !false; {9224#false} is VALID [2018-11-23 11:33:09,716 INFO L273 TraceCheckUtils]: 87: Hoare triple {9503#(not (= (_ bv0 32) __VERIFIER_assert_~cond))} assume 0bv32 == ~cond; {9224#false} is VALID [2018-11-23 11:33:09,717 INFO L273 TraceCheckUtils]: 86: Hoare triple {9507#(not (= |__VERIFIER_assert_#in~cond| (_ bv0 32)))} ~cond := #in~cond; {9503#(not (= (_ bv0 32) __VERIFIER_assert_~cond))} is VALID [2018-11-23 11:33:09,718 INFO L256 TraceCheckUtils]: 85: Hoare triple {9511#(bvslt main_~j~0 main_~bufsize~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {9507#(not (= |__VERIFIER_assert_#in~cond| (_ bv0 32)))} is VALID [2018-11-23 11:33:09,719 INFO L268 TraceCheckUtils]: 84: Hoare quadruple {9223#true} {9511#(bvslt main_~j~0 main_~bufsize~0)} #107#return; {9511#(bvslt main_~j~0 main_~bufsize~0)} is VALID [2018-11-23 11:33:09,719 INFO L273 TraceCheckUtils]: 83: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,719 INFO L273 TraceCheckUtils]: 82: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,720 INFO L273 TraceCheckUtils]: 81: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,720 INFO L256 TraceCheckUtils]: 80: Hoare triple {9511#(bvslt main_~j~0 main_~bufsize~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,721 INFO L268 TraceCheckUtils]: 79: Hoare quadruple {9223#true} {9511#(bvslt main_~j~0 main_~bufsize~0)} #105#return; {9511#(bvslt main_~j~0 main_~bufsize~0)} is VALID [2018-11-23 11:33:09,721 INFO L273 TraceCheckUtils]: 78: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,721 INFO L273 TraceCheckUtils]: 77: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,721 INFO L273 TraceCheckUtils]: 76: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,722 INFO L256 TraceCheckUtils]: 75: Hoare triple {9511#(bvslt main_~j~0 main_~bufsize~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,722 INFO L273 TraceCheckUtils]: 74: Hoare triple {9511#(bvslt main_~j~0 main_~bufsize~0)} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {9511#(bvslt main_~j~0 main_~bufsize~0)} is VALID [2018-11-23 11:33:09,723 INFO L273 TraceCheckUtils]: 73: Hoare triple {9511#(bvslt main_~j~0 main_~bufsize~0)} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {9511#(bvslt main_~j~0 main_~bufsize~0)} is VALID [2018-11-23 11:33:09,723 INFO L273 TraceCheckUtils]: 72: Hoare triple {9551#(bvslt (bvadd main_~j~0 (_ bv1 32)) main_~bufsize~0)} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {9511#(bvslt main_~j~0 main_~bufsize~0)} is VALID [2018-11-23 11:33:09,724 INFO L268 TraceCheckUtils]: 71: Hoare quadruple {9223#true} {9551#(bvslt (bvadd main_~j~0 (_ bv1 32)) main_~bufsize~0)} #103#return; {9551#(bvslt (bvadd main_~j~0 (_ bv1 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,724 INFO L273 TraceCheckUtils]: 70: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,724 INFO L273 TraceCheckUtils]: 69: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,725 INFO L273 TraceCheckUtils]: 68: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,725 INFO L256 TraceCheckUtils]: 67: Hoare triple {9551#(bvslt (bvadd main_~j~0 (_ bv1 32)) main_~bufsize~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,725 INFO L268 TraceCheckUtils]: 66: Hoare quadruple {9223#true} {9551#(bvslt (bvadd main_~j~0 (_ bv1 32)) main_~bufsize~0)} #101#return; {9551#(bvslt (bvadd main_~j~0 (_ bv1 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,725 INFO L273 TraceCheckUtils]: 65: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,725 INFO L273 TraceCheckUtils]: 64: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,726 INFO L273 TraceCheckUtils]: 63: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,726 INFO L256 TraceCheckUtils]: 62: Hoare triple {9551#(bvslt (bvadd main_~j~0 (_ bv1 32)) main_~bufsize~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,753 INFO L273 TraceCheckUtils]: 61: Hoare triple {9585#(bvslt (bvadd main_~j~0 (_ bv2 32)) main_~bufsize~0)} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {9551#(bvslt (bvadd main_~j~0 (_ bv1 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,772 INFO L268 TraceCheckUtils]: 60: Hoare quadruple {9223#true} {9585#(bvslt (bvadd main_~j~0 (_ bv2 32)) main_~bufsize~0)} #99#return; {9585#(bvslt (bvadd main_~j~0 (_ bv2 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,772 INFO L273 TraceCheckUtils]: 59: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,772 INFO L273 TraceCheckUtils]: 58: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,773 INFO L273 TraceCheckUtils]: 57: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,773 INFO L256 TraceCheckUtils]: 56: Hoare triple {9585#(bvslt (bvadd main_~j~0 (_ bv2 32)) main_~bufsize~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,787 INFO L268 TraceCheckUtils]: 55: Hoare quadruple {9223#true} {9585#(bvslt (bvadd main_~j~0 (_ bv2 32)) main_~bufsize~0)} #97#return; {9585#(bvslt (bvadd main_~j~0 (_ bv2 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,787 INFO L273 TraceCheckUtils]: 54: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,787 INFO L273 TraceCheckUtils]: 53: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,788 INFO L273 TraceCheckUtils]: 52: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,788 INFO L256 TraceCheckUtils]: 51: Hoare triple {9585#(bvslt (bvadd main_~j~0 (_ bv2 32)) main_~bufsize~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,790 INFO L268 TraceCheckUtils]: 50: Hoare quadruple {9223#true} {9585#(bvslt (bvadd main_~j~0 (_ bv2 32)) main_~bufsize~0)} #95#return; {9585#(bvslt (bvadd main_~j~0 (_ bv2 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,790 INFO L273 TraceCheckUtils]: 49: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,790 INFO L273 TraceCheckUtils]: 48: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,790 INFO L273 TraceCheckUtils]: 47: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,791 INFO L256 TraceCheckUtils]: 46: Hoare triple {9585#(bvslt (bvadd main_~j~0 (_ bv2 32)) main_~bufsize~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,791 INFO L268 TraceCheckUtils]: 45: Hoare quadruple {9223#true} {9585#(bvslt (bvadd main_~j~0 (_ bv2 32)) main_~bufsize~0)} #93#return; {9585#(bvslt (bvadd main_~j~0 (_ bv2 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,791 INFO L273 TraceCheckUtils]: 44: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,791 INFO L273 TraceCheckUtils]: 43: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,792 INFO L273 TraceCheckUtils]: 42: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,792 INFO L256 TraceCheckUtils]: 41: Hoare triple {9585#(bvslt (bvadd main_~j~0 (_ bv2 32)) main_~bufsize~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,838 INFO L273 TraceCheckUtils]: 40: Hoare triple {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {9585#(bvslt (bvadd main_~j~0 (_ bv2 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,852 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {9223#true} {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} #91#return; {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,852 INFO L273 TraceCheckUtils]: 38: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,852 INFO L273 TraceCheckUtils]: 37: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,853 INFO L273 TraceCheckUtils]: 36: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,853 INFO L256 TraceCheckUtils]: 35: Hoare triple {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,868 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {9223#true} {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} #89#return; {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,868 INFO L273 TraceCheckUtils]: 33: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,868 INFO L273 TraceCheckUtils]: 32: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,869 INFO L273 TraceCheckUtils]: 31: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,869 INFO L256 TraceCheckUtils]: 30: Hoare triple {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,875 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {9223#true} {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} #87#return; {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,875 INFO L273 TraceCheckUtils]: 28: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,875 INFO L273 TraceCheckUtils]: 27: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,875 INFO L273 TraceCheckUtils]: 26: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,876 INFO L256 TraceCheckUtils]: 25: Hoare triple {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,876 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {9223#true} {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} #85#return; {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,876 INFO L273 TraceCheckUtils]: 23: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,877 INFO L273 TraceCheckUtils]: 22: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,877 INFO L273 TraceCheckUtils]: 21: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,877 INFO L256 TraceCheckUtils]: 20: Hoare triple {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,878 INFO L273 TraceCheckUtils]: 19: Hoare triple {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,878 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {9223#true} {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} #83#return; {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,878 INFO L273 TraceCheckUtils]: 17: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,879 INFO L273 TraceCheckUtils]: 16: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,879 INFO L273 TraceCheckUtils]: 15: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,879 INFO L256 TraceCheckUtils]: 14: Hoare triple {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,880 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {9223#true} {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} #81#return; {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,880 INFO L273 TraceCheckUtils]: 12: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,880 INFO L273 TraceCheckUtils]: 11: Hoare triple {9223#true} assume !(0bv32 == ~cond); {9223#true} is VALID [2018-11-23 11:33:09,880 INFO L273 TraceCheckUtils]: 10: Hoare triple {9223#true} ~cond := #in~cond; {9223#true} is VALID [2018-11-23 11:33:09,881 INFO L256 TraceCheckUtils]: 9: Hoare triple {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {9223#true} is VALID [2018-11-23 11:33:09,882 INFO L273 TraceCheckUtils]: 8: Hoare triple {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,882 INFO L273 TraceCheckUtils]: 7: Hoare triple {9749#(or (not (bvslt main_~j~0 main_~limit~0)) (bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {9649#(bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0)} is VALID [2018-11-23 11:33:09,884 INFO L273 TraceCheckUtils]: 6: Hoare triple {9753#(or (not (bvslt (_ bv0 32) main_~limit~0)) (bvslt (_ bv3 32) main_~bufsize~0))} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {9749#(or (not (bvslt main_~j~0 main_~limit~0)) (bvslt (bvadd main_~j~0 (_ bv3 32)) main_~bufsize~0))} is VALID [2018-11-23 11:33:09,885 INFO L273 TraceCheckUtils]: 5: Hoare triple {9223#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {9753#(or (not (bvslt (_ bv0 32) main_~limit~0)) (bvslt (_ bv3 32) main_~bufsize~0))} is VALID [2018-11-23 11:33:09,886 INFO L273 TraceCheckUtils]: 4: Hoare triple {9223#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {9223#true} is VALID [2018-11-23 11:33:09,886 INFO L256 TraceCheckUtils]: 3: Hoare triple {9223#true} call #t~ret11 := main(); {9223#true} is VALID [2018-11-23 11:33:09,886 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {9223#true} {9223#true} #77#return; {9223#true} is VALID [2018-11-23 11:33:09,886 INFO L273 TraceCheckUtils]: 1: Hoare triple {9223#true} assume true; {9223#true} is VALID [2018-11-23 11:33:09,887 INFO L256 TraceCheckUtils]: 0: Hoare triple {9223#true} call ULTIMATE.init(); {9223#true} is VALID [2018-11-23 11:33:09,892 INFO L134 CoverageAnalysis]: Checked inductivity of 394 backedges. 28 proven. 2 refuted. 0 times theorem prover too weak. 364 trivial. 0 not checked. [2018-11-23 11:33:09,894 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 11:33:09,894 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [10, 10] total 18 [2018-11-23 11:33:09,895 INFO L78 Accepts]: Start accepts. Automaton has 18 states. Word has length 89 [2018-11-23 11:33:09,896 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 11:33:09,896 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 18 states. [2018-11-23 11:33:10,127 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 91 edges. 91 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:33:10,127 INFO L459 AbstractCegarLoop]: Interpolant automaton has 18 states [2018-11-23 11:33:10,127 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 18 interpolants. [2018-11-23 11:33:10,127 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=60, Invalid=246, Unknown=0, NotChecked=0, Total=306 [2018-11-23 11:33:10,128 INFO L87 Difference]: Start difference. First operand 227 states and 347 transitions. Second operand 18 states. [2018-11-23 11:33:22,886 WARN L180 SmtUtils]: Spent 143.00 ms on a formula simplification that was a NOOP. DAG size: 14 [2018-11-23 11:33:24,897 WARN L180 SmtUtils]: Spent 242.00 ms on a formula simplification. DAG size of input: 19 DAG size of output: 14 [2018-11-23 11:33:28,587 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:33:28,587 INFO L93 Difference]: Finished difference Result 278 states and 422 transitions. [2018-11-23 11:33:28,588 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 18 states. [2018-11-23 11:33:28,588 INFO L78 Accepts]: Start accepts. Automaton has 18 states. Word has length 89 [2018-11-23 11:33:28,588 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 11:33:28,588 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 18 states. [2018-11-23 11:33:28,592 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 18 states to 18 states and 219 transitions. [2018-11-23 11:33:28,593 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 18 states. [2018-11-23 11:33:28,597 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 18 states to 18 states and 219 transitions. [2018-11-23 11:33:28,597 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 18 states and 219 transitions. [2018-11-23 11:33:29,955 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 219 edges. 219 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:33:29,962 INFO L225 Difference]: With dead ends: 278 [2018-11-23 11:33:29,962 INFO L226 Difference]: Without dead ends: 272 [2018-11-23 11:33:29,963 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 189 GetRequests, 161 SyntacticMatches, 0 SemanticMatches, 28 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 106 ImplicationChecksByTransitivity, 1.9s TimeCoverageRelationStatistics Valid=197, Invalid=673, Unknown=0, NotChecked=0, Total=870 [2018-11-23 11:33:29,963 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 272 states. [2018-11-23 11:33:30,512 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 272 to 254. [2018-11-23 11:33:30,513 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 11:33:30,513 INFO L82 GeneralOperation]: Start isEquivalent. First operand 272 states. Second operand 254 states. [2018-11-23 11:33:30,513 INFO L74 IsIncluded]: Start isIncluded. First operand 272 states. Second operand 254 states. [2018-11-23 11:33:30,513 INFO L87 Difference]: Start difference. First operand 272 states. Second operand 254 states. [2018-11-23 11:33:30,525 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:33:30,525 INFO L93 Difference]: Finished difference Result 272 states and 412 transitions. [2018-11-23 11:33:30,526 INFO L276 IsEmpty]: Start isEmpty. Operand 272 states and 412 transitions. [2018-11-23 11:33:30,527 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:33:30,528 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:33:30,528 INFO L74 IsIncluded]: Start isIncluded. First operand 254 states. Second operand 272 states. [2018-11-23 11:33:30,528 INFO L87 Difference]: Start difference. First operand 254 states. Second operand 272 states. [2018-11-23 11:33:30,540 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:33:30,540 INFO L93 Difference]: Finished difference Result 272 states and 412 transitions. [2018-11-23 11:33:30,540 INFO L276 IsEmpty]: Start isEmpty. Operand 272 states and 412 transitions. [2018-11-23 11:33:30,542 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:33:30,542 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:33:30,543 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 11:33:30,543 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 11:33:30,543 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 254 states. [2018-11-23 11:33:30,554 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 254 states to 254 states and 391 transitions. [2018-11-23 11:33:30,554 INFO L78 Accepts]: Start accepts. Automaton has 254 states and 391 transitions. Word has length 89 [2018-11-23 11:33:30,555 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 11:33:30,555 INFO L480 AbstractCegarLoop]: Abstraction has 254 states and 391 transitions. [2018-11-23 11:33:30,555 INFO L481 AbstractCegarLoop]: Interpolant automaton has 18 states. [2018-11-23 11:33:30,555 INFO L276 IsEmpty]: Start isEmpty. Operand 254 states and 391 transitions. [2018-11-23 11:33:30,557 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 127 [2018-11-23 11:33:30,558 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 11:33:30,558 INFO L402 BasicCegarLoop]: trace histogram [22, 21, 21, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 11:33:30,558 INFO L423 AbstractCegarLoop]: === Iteration 12 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 11:33:30,558 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 11:33:30,558 INFO L82 PathProgramCache]: Analyzing trace with hash -1828129930, now seen corresponding path program 1 times [2018-11-23 11:33:30,559 INFO L223 ckRefinementStrategy]: Switched to mode CVC4_FPBP [2018-11-23 11:33:30,559 INFO L69 tionRefinementEngine]: Using refinement strategy WolfRefinementStrategy No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/cvc4nyu Starting monitored process 13 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 13 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk [2018-11-23 11:33:30,585 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 11:33:30,692 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:33:30,747 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:33:30,749 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 11:33:31,299 INFO L256 TraceCheckUtils]: 0: Hoare triple {11220#true} call ULTIMATE.init(); {11220#true} is VALID [2018-11-23 11:33:31,299 INFO L273 TraceCheckUtils]: 1: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,299 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {11220#true} {11220#true} #77#return; {11220#true} is VALID [2018-11-23 11:33:31,300 INFO L256 TraceCheckUtils]: 3: Hoare triple {11220#true} call #t~ret11 := main(); {11220#true} is VALID [2018-11-23 11:33:31,300 INFO L273 TraceCheckUtils]: 4: Hoare triple {11220#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {11220#true} is VALID [2018-11-23 11:33:31,300 INFO L273 TraceCheckUtils]: 5: Hoare triple {11220#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {11220#true} is VALID [2018-11-23 11:33:31,301 INFO L273 TraceCheckUtils]: 6: Hoare triple {11220#true} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {11243#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:31,301 INFO L273 TraceCheckUtils]: 7: Hoare triple {11243#(= main_~j~0 (_ bv0 32))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {11243#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:31,302 INFO L273 TraceCheckUtils]: 8: Hoare triple {11243#(= main_~j~0 (_ bv0 32))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {11243#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:31,302 INFO L256 TraceCheckUtils]: 9: Hoare triple {11243#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,302 INFO L273 TraceCheckUtils]: 10: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,302 INFO L273 TraceCheckUtils]: 11: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,302 INFO L273 TraceCheckUtils]: 12: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,303 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {11220#true} {11243#(= main_~j~0 (_ bv0 32))} #81#return; {11243#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:31,304 INFO L256 TraceCheckUtils]: 14: Hoare triple {11243#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,304 INFO L273 TraceCheckUtils]: 15: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,304 INFO L273 TraceCheckUtils]: 16: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,304 INFO L273 TraceCheckUtils]: 17: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,304 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {11220#true} {11243#(= main_~j~0 (_ bv0 32))} #83#return; {11243#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:31,305 INFO L273 TraceCheckUtils]: 19: Hoare triple {11243#(= main_~j~0 (_ bv0 32))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {11243#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:31,305 INFO L256 TraceCheckUtils]: 20: Hoare triple {11243#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,305 INFO L273 TraceCheckUtils]: 21: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,305 INFO L273 TraceCheckUtils]: 22: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,305 INFO L273 TraceCheckUtils]: 23: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,306 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {11220#true} {11243#(= main_~j~0 (_ bv0 32))} #85#return; {11243#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:31,306 INFO L256 TraceCheckUtils]: 25: Hoare triple {11243#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,306 INFO L273 TraceCheckUtils]: 26: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,306 INFO L273 TraceCheckUtils]: 27: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,306 INFO L273 TraceCheckUtils]: 28: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,307 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {11220#true} {11243#(= main_~j~0 (_ bv0 32))} #87#return; {11243#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:31,307 INFO L256 TraceCheckUtils]: 30: Hoare triple {11243#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,307 INFO L273 TraceCheckUtils]: 31: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,307 INFO L273 TraceCheckUtils]: 32: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,308 INFO L273 TraceCheckUtils]: 33: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,308 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {11220#true} {11243#(= main_~j~0 (_ bv0 32))} #89#return; {11243#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:31,309 INFO L256 TraceCheckUtils]: 35: Hoare triple {11243#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,309 INFO L273 TraceCheckUtils]: 36: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,309 INFO L273 TraceCheckUtils]: 37: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,309 INFO L273 TraceCheckUtils]: 38: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,310 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {11220#true} {11243#(= main_~j~0 (_ bv0 32))} #91#return; {11243#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:31,311 INFO L273 TraceCheckUtils]: 40: Hoare triple {11243#(= main_~j~0 (_ bv0 32))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {11346#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,311 INFO L256 TraceCheckUtils]: 41: Hoare triple {11346#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,311 INFO L273 TraceCheckUtils]: 42: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,311 INFO L273 TraceCheckUtils]: 43: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,311 INFO L273 TraceCheckUtils]: 44: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,312 INFO L268 TraceCheckUtils]: 45: Hoare quadruple {11220#true} {11346#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #93#return; {11346#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,312 INFO L256 TraceCheckUtils]: 46: Hoare triple {11346#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,312 INFO L273 TraceCheckUtils]: 47: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,312 INFO L273 TraceCheckUtils]: 48: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,312 INFO L273 TraceCheckUtils]: 49: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,313 INFO L268 TraceCheckUtils]: 50: Hoare quadruple {11220#true} {11346#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #95#return; {11346#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,313 INFO L256 TraceCheckUtils]: 51: Hoare triple {11346#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,313 INFO L273 TraceCheckUtils]: 52: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,313 INFO L273 TraceCheckUtils]: 53: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,313 INFO L273 TraceCheckUtils]: 54: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,314 INFO L268 TraceCheckUtils]: 55: Hoare quadruple {11220#true} {11346#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #97#return; {11346#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,314 INFO L256 TraceCheckUtils]: 56: Hoare triple {11346#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,314 INFO L273 TraceCheckUtils]: 57: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,315 INFO L273 TraceCheckUtils]: 58: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,315 INFO L273 TraceCheckUtils]: 59: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,316 INFO L268 TraceCheckUtils]: 60: Hoare quadruple {11220#true} {11346#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #99#return; {11346#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,316 INFO L273 TraceCheckUtils]: 61: Hoare triple {11346#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {11410#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,316 INFO L256 TraceCheckUtils]: 62: Hoare triple {11410#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,316 INFO L273 TraceCheckUtils]: 63: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,317 INFO L273 TraceCheckUtils]: 64: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,317 INFO L273 TraceCheckUtils]: 65: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,317 INFO L268 TraceCheckUtils]: 66: Hoare quadruple {11220#true} {11410#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} #101#return; {11410#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,317 INFO L256 TraceCheckUtils]: 67: Hoare triple {11410#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,317 INFO L273 TraceCheckUtils]: 68: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,318 INFO L273 TraceCheckUtils]: 69: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,318 INFO L273 TraceCheckUtils]: 70: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,318 INFO L268 TraceCheckUtils]: 71: Hoare quadruple {11220#true} {11410#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} #103#return; {11410#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,319 INFO L273 TraceCheckUtils]: 72: Hoare triple {11410#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,319 INFO L273 TraceCheckUtils]: 73: Hoare triple {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,319 INFO L273 TraceCheckUtils]: 74: Hoare triple {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,320 INFO L256 TraceCheckUtils]: 75: Hoare triple {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,320 INFO L273 TraceCheckUtils]: 76: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,320 INFO L273 TraceCheckUtils]: 77: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,320 INFO L273 TraceCheckUtils]: 78: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,320 INFO L268 TraceCheckUtils]: 79: Hoare quadruple {11220#true} {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} #81#return; {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,321 INFO L256 TraceCheckUtils]: 80: Hoare triple {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,321 INFO L273 TraceCheckUtils]: 81: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,321 INFO L273 TraceCheckUtils]: 82: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,321 INFO L273 TraceCheckUtils]: 83: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,322 INFO L268 TraceCheckUtils]: 84: Hoare quadruple {11220#true} {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} #83#return; {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,322 INFO L273 TraceCheckUtils]: 85: Hoare triple {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,323 INFO L256 TraceCheckUtils]: 86: Hoare triple {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,323 INFO L273 TraceCheckUtils]: 87: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,323 INFO L273 TraceCheckUtils]: 88: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,323 INFO L273 TraceCheckUtils]: 89: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,324 INFO L268 TraceCheckUtils]: 90: Hoare quadruple {11220#true} {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} #85#return; {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,324 INFO L256 TraceCheckUtils]: 91: Hoare triple {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,325 INFO L273 TraceCheckUtils]: 92: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,325 INFO L273 TraceCheckUtils]: 93: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,325 INFO L273 TraceCheckUtils]: 94: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,326 INFO L268 TraceCheckUtils]: 95: Hoare quadruple {11220#true} {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} #87#return; {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,326 INFO L256 TraceCheckUtils]: 96: Hoare triple {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,326 INFO L273 TraceCheckUtils]: 97: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,327 INFO L273 TraceCheckUtils]: 98: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,327 INFO L273 TraceCheckUtils]: 99: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,328 INFO L268 TraceCheckUtils]: 100: Hoare quadruple {11220#true} {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} #89#return; {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,328 INFO L256 TraceCheckUtils]: 101: Hoare triple {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,328 INFO L273 TraceCheckUtils]: 102: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,329 INFO L273 TraceCheckUtils]: 103: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,329 INFO L273 TraceCheckUtils]: 104: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,329 INFO L268 TraceCheckUtils]: 105: Hoare quadruple {11220#true} {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} #91#return; {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,330 INFO L273 TraceCheckUtils]: 106: Hoare triple {11444#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {11547#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,330 INFO L256 TraceCheckUtils]: 107: Hoare triple {11547#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,330 INFO L273 TraceCheckUtils]: 108: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,330 INFO L273 TraceCheckUtils]: 109: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,330 INFO L273 TraceCheckUtils]: 110: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,331 INFO L268 TraceCheckUtils]: 111: Hoare quadruple {11220#true} {11547#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #93#return; {11547#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,331 INFO L256 TraceCheckUtils]: 112: Hoare triple {11547#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,331 INFO L273 TraceCheckUtils]: 113: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,331 INFO L273 TraceCheckUtils]: 114: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,332 INFO L273 TraceCheckUtils]: 115: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,332 INFO L268 TraceCheckUtils]: 116: Hoare quadruple {11220#true} {11547#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #95#return; {11547#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,332 INFO L256 TraceCheckUtils]: 117: Hoare triple {11547#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,332 INFO L273 TraceCheckUtils]: 118: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,332 INFO L273 TraceCheckUtils]: 119: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,333 INFO L273 TraceCheckUtils]: 120: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,333 INFO L268 TraceCheckUtils]: 121: Hoare quadruple {11220#true} {11547#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #97#return; {11547#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,334 INFO L256 TraceCheckUtils]: 122: Hoare triple {11547#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {11596#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,335 INFO L273 TraceCheckUtils]: 123: Hoare triple {11596#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} ~cond := #in~cond; {11600#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:31,335 INFO L273 TraceCheckUtils]: 124: Hoare triple {11600#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} assume 0bv32 == ~cond; {11221#false} is VALID [2018-11-23 11:33:31,335 INFO L273 TraceCheckUtils]: 125: Hoare triple {11221#false} assume !false; {11221#false} is VALID [2018-11-23 11:33:31,350 INFO L134 CoverageAnalysis]: Checked inductivity of 896 backedges. 42 proven. 14 refuted. 0 times theorem prover too weak. 840 trivial. 0 not checked. [2018-11-23 11:33:31,351 INFO L316 TraceCheckSpWp]: Computing backward predicates... [2018-11-23 11:33:31,775 INFO L273 TraceCheckUtils]: 125: Hoare triple {11221#false} assume !false; {11221#false} is VALID [2018-11-23 11:33:31,776 INFO L273 TraceCheckUtils]: 124: Hoare triple {11610#(not (= (_ bv0 32) __VERIFIER_assert_~cond))} assume 0bv32 == ~cond; {11221#false} is VALID [2018-11-23 11:33:31,777 INFO L273 TraceCheckUtils]: 123: Hoare triple {11614#(not (= |__VERIFIER_assert_#in~cond| (_ bv0 32)))} ~cond := #in~cond; {11610#(not (= (_ bv0 32) __VERIFIER_assert_~cond))} is VALID [2018-11-23 11:33:31,778 INFO L256 TraceCheckUtils]: 122: Hoare triple {11618#(bvsle (_ bv0 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {11614#(not (= |__VERIFIER_assert_#in~cond| (_ bv0 32)))} is VALID [2018-11-23 11:33:31,779 INFO L268 TraceCheckUtils]: 121: Hoare quadruple {11220#true} {11618#(bvsle (_ bv0 32) main_~j~0)} #97#return; {11618#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:33:31,779 INFO L273 TraceCheckUtils]: 120: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,779 INFO L273 TraceCheckUtils]: 119: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,779 INFO L273 TraceCheckUtils]: 118: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,780 INFO L256 TraceCheckUtils]: 117: Hoare triple {11618#(bvsle (_ bv0 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,781 INFO L268 TraceCheckUtils]: 116: Hoare quadruple {11220#true} {11618#(bvsle (_ bv0 32) main_~j~0)} #95#return; {11618#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:33:31,781 INFO L273 TraceCheckUtils]: 115: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,781 INFO L273 TraceCheckUtils]: 114: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,781 INFO L273 TraceCheckUtils]: 113: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,782 INFO L256 TraceCheckUtils]: 112: Hoare triple {11618#(bvsle (_ bv0 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,783 INFO L268 TraceCheckUtils]: 111: Hoare quadruple {11220#true} {11618#(bvsle (_ bv0 32) main_~j~0)} #93#return; {11618#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:33:31,783 INFO L273 TraceCheckUtils]: 110: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,783 INFO L273 TraceCheckUtils]: 109: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,783 INFO L273 TraceCheckUtils]: 108: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,783 INFO L256 TraceCheckUtils]: 107: Hoare triple {11618#(bvsle (_ bv0 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,784 INFO L273 TraceCheckUtils]: 106: Hoare triple {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {11618#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:33:31,784 INFO L268 TraceCheckUtils]: 105: Hoare quadruple {11220#true} {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} #91#return; {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:31,784 INFO L273 TraceCheckUtils]: 104: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,784 INFO L273 TraceCheckUtils]: 103: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,785 INFO L273 TraceCheckUtils]: 102: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,785 INFO L256 TraceCheckUtils]: 101: Hoare triple {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,786 INFO L268 TraceCheckUtils]: 100: Hoare quadruple {11220#true} {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} #89#return; {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:31,787 INFO L273 TraceCheckUtils]: 99: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,787 INFO L273 TraceCheckUtils]: 98: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,787 INFO L273 TraceCheckUtils]: 97: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,787 INFO L256 TraceCheckUtils]: 96: Hoare triple {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,788 INFO L268 TraceCheckUtils]: 95: Hoare quadruple {11220#true} {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} #87#return; {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:31,788 INFO L273 TraceCheckUtils]: 94: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,789 INFO L273 TraceCheckUtils]: 93: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,789 INFO L273 TraceCheckUtils]: 92: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,789 INFO L256 TraceCheckUtils]: 91: Hoare triple {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,790 INFO L268 TraceCheckUtils]: 90: Hoare quadruple {11220#true} {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} #85#return; {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:31,790 INFO L273 TraceCheckUtils]: 89: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,790 INFO L273 TraceCheckUtils]: 88: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,791 INFO L273 TraceCheckUtils]: 87: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,791 INFO L256 TraceCheckUtils]: 86: Hoare triple {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,791 INFO L273 TraceCheckUtils]: 85: Hoare triple {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:31,792 INFO L268 TraceCheckUtils]: 84: Hoare quadruple {11220#true} {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} #83#return; {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:31,792 INFO L273 TraceCheckUtils]: 83: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,792 INFO L273 TraceCheckUtils]: 82: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,792 INFO L273 TraceCheckUtils]: 81: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,792 INFO L256 TraceCheckUtils]: 80: Hoare triple {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,793 INFO L268 TraceCheckUtils]: 79: Hoare quadruple {11220#true} {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} #81#return; {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:31,793 INFO L273 TraceCheckUtils]: 78: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,793 INFO L273 TraceCheckUtils]: 77: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,793 INFO L273 TraceCheckUtils]: 76: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,794 INFO L256 TraceCheckUtils]: 75: Hoare triple {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,794 INFO L273 TraceCheckUtils]: 74: Hoare triple {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:31,795 INFO L273 TraceCheckUtils]: 73: Hoare triple {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:31,798 INFO L273 TraceCheckUtils]: 72: Hoare triple {11770#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {11667#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:31,798 INFO L268 TraceCheckUtils]: 71: Hoare quadruple {11220#true} {11770#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} #103#return; {11770#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:31,799 INFO L273 TraceCheckUtils]: 70: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,799 INFO L273 TraceCheckUtils]: 69: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,799 INFO L273 TraceCheckUtils]: 68: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,799 INFO L256 TraceCheckUtils]: 67: Hoare triple {11770#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,799 INFO L268 TraceCheckUtils]: 66: Hoare quadruple {11220#true} {11770#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} #101#return; {11770#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:31,800 INFO L273 TraceCheckUtils]: 65: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,800 INFO L273 TraceCheckUtils]: 64: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,800 INFO L273 TraceCheckUtils]: 63: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,800 INFO L256 TraceCheckUtils]: 62: Hoare triple {11770#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,804 INFO L273 TraceCheckUtils]: 61: Hoare triple {11804#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {11770#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:31,805 INFO L268 TraceCheckUtils]: 60: Hoare quadruple {11220#true} {11804#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #99#return; {11804#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:31,805 INFO L273 TraceCheckUtils]: 59: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,806 INFO L273 TraceCheckUtils]: 58: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,806 INFO L273 TraceCheckUtils]: 57: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,806 INFO L256 TraceCheckUtils]: 56: Hoare triple {11804#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,806 INFO L268 TraceCheckUtils]: 55: Hoare quadruple {11220#true} {11804#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #97#return; {11804#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:31,807 INFO L273 TraceCheckUtils]: 54: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,807 INFO L273 TraceCheckUtils]: 53: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,807 INFO L273 TraceCheckUtils]: 52: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,807 INFO L256 TraceCheckUtils]: 51: Hoare triple {11804#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,808 INFO L268 TraceCheckUtils]: 50: Hoare quadruple {11220#true} {11804#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #95#return; {11804#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:31,808 INFO L273 TraceCheckUtils]: 49: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,808 INFO L273 TraceCheckUtils]: 48: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,808 INFO L273 TraceCheckUtils]: 47: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,808 INFO L256 TraceCheckUtils]: 46: Hoare triple {11804#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,809 INFO L268 TraceCheckUtils]: 45: Hoare quadruple {11220#true} {11804#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #93#return; {11804#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:31,809 INFO L273 TraceCheckUtils]: 44: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,810 INFO L273 TraceCheckUtils]: 43: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,810 INFO L273 TraceCheckUtils]: 42: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,810 INFO L256 TraceCheckUtils]: 41: Hoare triple {11804#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,814 INFO L273 TraceCheckUtils]: 40: Hoare triple {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {11804#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:31,815 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {11220#true} {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} #91#return; {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:33:31,815 INFO L273 TraceCheckUtils]: 38: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,816 INFO L273 TraceCheckUtils]: 37: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,816 INFO L273 TraceCheckUtils]: 36: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,816 INFO L256 TraceCheckUtils]: 35: Hoare triple {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,817 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {11220#true} {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} #89#return; {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:33:31,817 INFO L273 TraceCheckUtils]: 33: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,817 INFO L273 TraceCheckUtils]: 32: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,817 INFO L273 TraceCheckUtils]: 31: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,817 INFO L256 TraceCheckUtils]: 30: Hoare triple {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,818 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {11220#true} {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} #87#return; {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:33:31,818 INFO L273 TraceCheckUtils]: 28: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,818 INFO L273 TraceCheckUtils]: 27: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,818 INFO L273 TraceCheckUtils]: 26: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,818 INFO L256 TraceCheckUtils]: 25: Hoare triple {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,819 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {11220#true} {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} #85#return; {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:33:31,819 INFO L273 TraceCheckUtils]: 23: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,819 INFO L273 TraceCheckUtils]: 22: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,819 INFO L273 TraceCheckUtils]: 21: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,819 INFO L256 TraceCheckUtils]: 20: Hoare triple {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,820 INFO L273 TraceCheckUtils]: 19: Hoare triple {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:33:31,820 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {11220#true} {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} #83#return; {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:33:31,821 INFO L273 TraceCheckUtils]: 17: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,821 INFO L273 TraceCheckUtils]: 16: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,821 INFO L273 TraceCheckUtils]: 15: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,821 INFO L256 TraceCheckUtils]: 14: Hoare triple {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,821 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {11220#true} {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} #81#return; {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:33:31,822 INFO L273 TraceCheckUtils]: 12: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,822 INFO L273 TraceCheckUtils]: 11: Hoare triple {11220#true} assume !(0bv32 == ~cond); {11220#true} is VALID [2018-11-23 11:33:31,822 INFO L273 TraceCheckUtils]: 10: Hoare triple {11220#true} ~cond := #in~cond; {11220#true} is VALID [2018-11-23 11:33:31,822 INFO L256 TraceCheckUtils]: 9: Hoare triple {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {11220#true} is VALID [2018-11-23 11:33:31,823 INFO L273 TraceCheckUtils]: 8: Hoare triple {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:33:31,823 INFO L273 TraceCheckUtils]: 7: Hoare triple {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:33:31,824 INFO L273 TraceCheckUtils]: 6: Hoare triple {11220#true} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {11868#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:33:31,824 INFO L273 TraceCheckUtils]: 5: Hoare triple {11220#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {11220#true} is VALID [2018-11-23 11:33:31,824 INFO L273 TraceCheckUtils]: 4: Hoare triple {11220#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {11220#true} is VALID [2018-11-23 11:33:31,824 INFO L256 TraceCheckUtils]: 3: Hoare triple {11220#true} call #t~ret11 := main(); {11220#true} is VALID [2018-11-23 11:33:31,825 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {11220#true} {11220#true} #77#return; {11220#true} is VALID [2018-11-23 11:33:31,825 INFO L273 TraceCheckUtils]: 1: Hoare triple {11220#true} assume true; {11220#true} is VALID [2018-11-23 11:33:31,825 INFO L256 TraceCheckUtils]: 0: Hoare triple {11220#true} call ULTIMATE.init(); {11220#true} is VALID [2018-11-23 11:33:31,835 INFO L134 CoverageAnalysis]: Checked inductivity of 896 backedges. 42 proven. 14 refuted. 0 times theorem prover too weak. 840 trivial. 0 not checked. [2018-11-23 11:33:31,837 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 11:33:31,838 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [9, 9] total 16 [2018-11-23 11:33:31,838 INFO L78 Accepts]: Start accepts. Automaton has 16 states. Word has length 126 [2018-11-23 11:33:31,839 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 11:33:31,839 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 16 states. [2018-11-23 11:33:32,102 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 122 edges. 122 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:33:32,102 INFO L459 AbstractCegarLoop]: Interpolant automaton has 16 states [2018-11-23 11:33:32,102 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 16 interpolants. [2018-11-23 11:33:32,102 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=56, Invalid=184, Unknown=0, NotChecked=0, Total=240 [2018-11-23 11:33:32,103 INFO L87 Difference]: Start difference. First operand 254 states and 391 transitions. Second operand 16 states. [2018-11-23 11:33:46,626 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:33:46,627 INFO L93 Difference]: Finished difference Result 438 states and 687 transitions. [2018-11-23 11:33:46,627 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 15 states. [2018-11-23 11:33:46,627 INFO L78 Accepts]: Start accepts. Automaton has 16 states. Word has length 126 [2018-11-23 11:33:46,628 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 11:33:46,628 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 16 states. [2018-11-23 11:33:46,642 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 15 states to 15 states and 440 transitions. [2018-11-23 11:33:46,642 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 16 states. [2018-11-23 11:33:46,655 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 15 states to 15 states and 440 transitions. [2018-11-23 11:33:46,655 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 15 states and 440 transitions. [2018-11-23 11:33:47,936 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 440 edges. 440 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:33:47,950 INFO L225 Difference]: With dead ends: 438 [2018-11-23 11:33:47,950 INFO L226 Difference]: Without dead ends: 416 [2018-11-23 11:33:47,951 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 256 GetRequests, 237 SyntacticMatches, 0 SemanticMatches, 19 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 21 ImplicationChecksByTransitivity, 0.4s TimeCoverageRelationStatistics Valid=110, Invalid=310, Unknown=0, NotChecked=0, Total=420 [2018-11-23 11:33:47,951 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 416 states. [2018-11-23 11:33:49,029 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 416 to 381. [2018-11-23 11:33:49,029 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 11:33:49,029 INFO L82 GeneralOperation]: Start isEquivalent. First operand 416 states. Second operand 381 states. [2018-11-23 11:33:49,029 INFO L74 IsIncluded]: Start isIncluded. First operand 416 states. Second operand 381 states. [2018-11-23 11:33:49,029 INFO L87 Difference]: Start difference. First operand 416 states. Second operand 381 states. [2018-11-23 11:33:49,055 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:33:49,055 INFO L93 Difference]: Finished difference Result 416 states and 645 transitions. [2018-11-23 11:33:49,056 INFO L276 IsEmpty]: Start isEmpty. Operand 416 states and 645 transitions. [2018-11-23 11:33:49,059 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:33:49,059 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:33:49,059 INFO L74 IsIncluded]: Start isIncluded. First operand 381 states. Second operand 416 states. [2018-11-23 11:33:49,060 INFO L87 Difference]: Start difference. First operand 381 states. Second operand 416 states. [2018-11-23 11:33:49,086 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:33:49,086 INFO L93 Difference]: Finished difference Result 416 states and 645 transitions. [2018-11-23 11:33:49,086 INFO L276 IsEmpty]: Start isEmpty. Operand 416 states and 645 transitions. [2018-11-23 11:33:49,089 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:33:49,089 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:33:49,090 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 11:33:49,090 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 11:33:49,090 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 381 states. [2018-11-23 11:33:49,114 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 381 states to 381 states and 595 transitions. [2018-11-23 11:33:49,114 INFO L78 Accepts]: Start accepts. Automaton has 381 states and 595 transitions. Word has length 126 [2018-11-23 11:33:49,115 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 11:33:49,115 INFO L480 AbstractCegarLoop]: Abstraction has 381 states and 595 transitions. [2018-11-23 11:33:49,115 INFO L481 AbstractCegarLoop]: Interpolant automaton has 16 states. [2018-11-23 11:33:49,115 INFO L276 IsEmpty]: Start isEmpty. Operand 381 states and 595 transitions. [2018-11-23 11:33:49,121 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 261 [2018-11-23 11:33:49,122 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 11:33:49,122 INFO L402 BasicCegarLoop]: trace histogram [46, 45, 45, 5, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 11:33:49,122 INFO L423 AbstractCegarLoop]: === Iteration 13 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 11:33:49,122 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 11:33:49,123 INFO L82 PathProgramCache]: Analyzing trace with hash -1061971679, now seen corresponding path program 1 times [2018-11-23 11:33:49,123 INFO L223 ckRefinementStrategy]: Switched to mode CVC4_FPBP [2018-11-23 11:33:49,124 INFO L69 tionRefinementEngine]: Using refinement strategy WolfRefinementStrategy No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/cvc4nyu Starting monitored process 14 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 14 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk [2018-11-23 11:33:49,151 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 11:33:49,428 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:33:49,552 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:33:49,556 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 11:33:49,995 INFO L256 TraceCheckUtils]: 0: Hoare triple {14193#true} call ULTIMATE.init(); {14193#true} is VALID [2018-11-23 11:33:49,995 INFO L273 TraceCheckUtils]: 1: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:49,995 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {14193#true} {14193#true} #77#return; {14193#true} is VALID [2018-11-23 11:33:49,995 INFO L256 TraceCheckUtils]: 3: Hoare triple {14193#true} call #t~ret11 := main(); {14193#true} is VALID [2018-11-23 11:33:49,995 INFO L273 TraceCheckUtils]: 4: Hoare triple {14193#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {14193#true} is VALID [2018-11-23 11:33:49,996 INFO L273 TraceCheckUtils]: 5: Hoare triple {14193#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {14193#true} is VALID [2018-11-23 11:33:49,996 INFO L273 TraceCheckUtils]: 6: Hoare triple {14193#true} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {14216#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:49,997 INFO L273 TraceCheckUtils]: 7: Hoare triple {14216#(= main_~j~0 (_ bv0 32))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {14216#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:49,997 INFO L273 TraceCheckUtils]: 8: Hoare triple {14216#(= main_~j~0 (_ bv0 32))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {14216#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:49,997 INFO L256 TraceCheckUtils]: 9: Hoare triple {14216#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:49,997 INFO L273 TraceCheckUtils]: 10: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:49,998 INFO L273 TraceCheckUtils]: 11: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:49,998 INFO L273 TraceCheckUtils]: 12: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:49,998 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {14193#true} {14216#(= main_~j~0 (_ bv0 32))} #81#return; {14216#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:49,998 INFO L256 TraceCheckUtils]: 14: Hoare triple {14216#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:49,998 INFO L273 TraceCheckUtils]: 15: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:49,998 INFO L273 TraceCheckUtils]: 16: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:49,999 INFO L273 TraceCheckUtils]: 17: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:49,999 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {14193#true} {14216#(= main_~j~0 (_ bv0 32))} #83#return; {14216#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:49,999 INFO L273 TraceCheckUtils]: 19: Hoare triple {14216#(= main_~j~0 (_ bv0 32))} assume 0bv32 != #t~nondet3;havoc #t~nondet3; {14216#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:49,999 INFO L256 TraceCheckUtils]: 20: Hoare triple {14216#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,000 INFO L273 TraceCheckUtils]: 21: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,000 INFO L273 TraceCheckUtils]: 22: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,000 INFO L273 TraceCheckUtils]: 23: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,000 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {14193#true} {14216#(= main_~j~0 (_ bv0 32))} #105#return; {14216#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:50,001 INFO L256 TraceCheckUtils]: 25: Hoare triple {14216#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,001 INFO L273 TraceCheckUtils]: 26: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,001 INFO L273 TraceCheckUtils]: 27: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,001 INFO L273 TraceCheckUtils]: 28: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,002 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {14193#true} {14216#(= main_~j~0 (_ bv0 32))} #107#return; {14216#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:50,002 INFO L256 TraceCheckUtils]: 30: Hoare triple {14216#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,002 INFO L273 TraceCheckUtils]: 31: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,003 INFO L273 TraceCheckUtils]: 32: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,003 INFO L273 TraceCheckUtils]: 33: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,003 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {14193#true} {14216#(= main_~j~0 (_ bv0 32))} #109#return; {14216#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:50,004 INFO L256 TraceCheckUtils]: 35: Hoare triple {14216#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,004 INFO L273 TraceCheckUtils]: 36: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,004 INFO L273 TraceCheckUtils]: 37: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,004 INFO L273 TraceCheckUtils]: 38: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,005 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {14193#true} {14216#(= main_~j~0 (_ bv0 32))} #111#return; {14216#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:33:50,005 INFO L273 TraceCheckUtils]: 40: Hoare triple {14216#(= main_~j~0 (_ bv0 32))} #t~post9 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post9);havoc #t~post9;#t~post10 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post10);havoc #t~post10; {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,006 INFO L273 TraceCheckUtils]: 41: Hoare triple {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,006 INFO L273 TraceCheckUtils]: 42: Hoare triple {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,006 INFO L256 TraceCheckUtils]: 43: Hoare triple {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,006 INFO L273 TraceCheckUtils]: 44: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,007 INFO L273 TraceCheckUtils]: 45: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,007 INFO L273 TraceCheckUtils]: 46: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,007 INFO L268 TraceCheckUtils]: 47: Hoare quadruple {14193#true} {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #81#return; {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,007 INFO L256 TraceCheckUtils]: 48: Hoare triple {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,007 INFO L273 TraceCheckUtils]: 49: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,007 INFO L273 TraceCheckUtils]: 50: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,008 INFO L273 TraceCheckUtils]: 51: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,008 INFO L268 TraceCheckUtils]: 52: Hoare quadruple {14193#true} {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #83#return; {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,008 INFO L273 TraceCheckUtils]: 53: Hoare triple {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,008 INFO L256 TraceCheckUtils]: 54: Hoare triple {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,009 INFO L273 TraceCheckUtils]: 55: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,009 INFO L273 TraceCheckUtils]: 56: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,009 INFO L273 TraceCheckUtils]: 57: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,010 INFO L268 TraceCheckUtils]: 58: Hoare quadruple {14193#true} {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #85#return; {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,010 INFO L256 TraceCheckUtils]: 59: Hoare triple {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,010 INFO L273 TraceCheckUtils]: 60: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,010 INFO L273 TraceCheckUtils]: 61: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,011 INFO L273 TraceCheckUtils]: 62: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,011 INFO L268 TraceCheckUtils]: 63: Hoare quadruple {14193#true} {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #87#return; {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,012 INFO L256 TraceCheckUtils]: 64: Hoare triple {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,012 INFO L273 TraceCheckUtils]: 65: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,012 INFO L273 TraceCheckUtils]: 66: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,012 INFO L273 TraceCheckUtils]: 67: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,013 INFO L268 TraceCheckUtils]: 68: Hoare quadruple {14193#true} {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #89#return; {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,013 INFO L256 TraceCheckUtils]: 69: Hoare triple {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,013 INFO L273 TraceCheckUtils]: 70: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,014 INFO L273 TraceCheckUtils]: 71: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,014 INFO L273 TraceCheckUtils]: 72: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,014 INFO L268 TraceCheckUtils]: 73: Hoare quadruple {14193#true} {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #91#return; {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,015 INFO L273 TraceCheckUtils]: 74: Hoare triple {14319#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {14422#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,015 INFO L256 TraceCheckUtils]: 75: Hoare triple {14422#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,015 INFO L273 TraceCheckUtils]: 76: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,015 INFO L273 TraceCheckUtils]: 77: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,015 INFO L273 TraceCheckUtils]: 78: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,016 INFO L268 TraceCheckUtils]: 79: Hoare quadruple {14193#true} {14422#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} #93#return; {14422#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,016 INFO L256 TraceCheckUtils]: 80: Hoare triple {14422#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,016 INFO L273 TraceCheckUtils]: 81: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,016 INFO L273 TraceCheckUtils]: 82: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,016 INFO L273 TraceCheckUtils]: 83: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,017 INFO L268 TraceCheckUtils]: 84: Hoare quadruple {14193#true} {14422#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} #95#return; {14422#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,017 INFO L256 TraceCheckUtils]: 85: Hoare triple {14422#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,017 INFO L273 TraceCheckUtils]: 86: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,018 INFO L273 TraceCheckUtils]: 87: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,018 INFO L273 TraceCheckUtils]: 88: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,018 INFO L268 TraceCheckUtils]: 89: Hoare quadruple {14193#true} {14422#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} #97#return; {14422#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,019 INFO L256 TraceCheckUtils]: 90: Hoare triple {14422#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,019 INFO L273 TraceCheckUtils]: 91: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,019 INFO L273 TraceCheckUtils]: 92: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,019 INFO L273 TraceCheckUtils]: 93: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,020 INFO L268 TraceCheckUtils]: 94: Hoare quadruple {14193#true} {14422#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} #99#return; {14422#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,021 INFO L273 TraceCheckUtils]: 95: Hoare triple {14422#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {14486#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,021 INFO L256 TraceCheckUtils]: 96: Hoare triple {14486#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,021 INFO L273 TraceCheckUtils]: 97: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,021 INFO L273 TraceCheckUtils]: 98: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,022 INFO L273 TraceCheckUtils]: 99: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,022 INFO L268 TraceCheckUtils]: 100: Hoare quadruple {14193#true} {14486#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} #101#return; {14486#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,022 INFO L256 TraceCheckUtils]: 101: Hoare triple {14486#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,022 INFO L273 TraceCheckUtils]: 102: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,022 INFO L273 TraceCheckUtils]: 103: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,023 INFO L273 TraceCheckUtils]: 104: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,023 INFO L268 TraceCheckUtils]: 105: Hoare quadruple {14193#true} {14486#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} #103#return; {14486#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,024 INFO L273 TraceCheckUtils]: 106: Hoare triple {14486#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,025 INFO L273 TraceCheckUtils]: 107: Hoare triple {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,025 INFO L273 TraceCheckUtils]: 108: Hoare triple {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,025 INFO L256 TraceCheckUtils]: 109: Hoare triple {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,026 INFO L273 TraceCheckUtils]: 110: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,026 INFO L273 TraceCheckUtils]: 111: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,026 INFO L273 TraceCheckUtils]: 112: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,027 INFO L268 TraceCheckUtils]: 113: Hoare quadruple {14193#true} {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #81#return; {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,027 INFO L256 TraceCheckUtils]: 114: Hoare triple {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,027 INFO L273 TraceCheckUtils]: 115: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,027 INFO L273 TraceCheckUtils]: 116: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,027 INFO L273 TraceCheckUtils]: 117: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,028 INFO L268 TraceCheckUtils]: 118: Hoare quadruple {14193#true} {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #83#return; {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,029 INFO L273 TraceCheckUtils]: 119: Hoare triple {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,029 INFO L256 TraceCheckUtils]: 120: Hoare triple {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,029 INFO L273 TraceCheckUtils]: 121: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,029 INFO L273 TraceCheckUtils]: 122: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,030 INFO L273 TraceCheckUtils]: 123: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,030 INFO L268 TraceCheckUtils]: 124: Hoare quadruple {14193#true} {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #85#return; {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,030 INFO L256 TraceCheckUtils]: 125: Hoare triple {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,031 INFO L273 TraceCheckUtils]: 126: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,031 INFO L273 TraceCheckUtils]: 127: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,031 INFO L273 TraceCheckUtils]: 128: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,032 INFO L268 TraceCheckUtils]: 129: Hoare quadruple {14193#true} {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #87#return; {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,032 INFO L256 TraceCheckUtils]: 130: Hoare triple {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,032 INFO L273 TraceCheckUtils]: 131: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,032 INFO L273 TraceCheckUtils]: 132: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,033 INFO L273 TraceCheckUtils]: 133: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,033 INFO L268 TraceCheckUtils]: 134: Hoare quadruple {14193#true} {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #89#return; {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,033 INFO L256 TraceCheckUtils]: 135: Hoare triple {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,034 INFO L273 TraceCheckUtils]: 136: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,034 INFO L273 TraceCheckUtils]: 137: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,034 INFO L273 TraceCheckUtils]: 138: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,035 INFO L268 TraceCheckUtils]: 139: Hoare quadruple {14193#true} {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #91#return; {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,035 INFO L273 TraceCheckUtils]: 140: Hoare triple {14520#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {14623#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,035 INFO L256 TraceCheckUtils]: 141: Hoare triple {14623#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,035 INFO L273 TraceCheckUtils]: 142: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,035 INFO L273 TraceCheckUtils]: 143: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,036 INFO L273 TraceCheckUtils]: 144: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,036 INFO L268 TraceCheckUtils]: 145: Hoare quadruple {14193#true} {14623#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} #93#return; {14623#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,036 INFO L256 TraceCheckUtils]: 146: Hoare triple {14623#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,036 INFO L273 TraceCheckUtils]: 147: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,036 INFO L273 TraceCheckUtils]: 148: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,036 INFO L273 TraceCheckUtils]: 149: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,037 INFO L268 TraceCheckUtils]: 150: Hoare quadruple {14193#true} {14623#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} #95#return; {14623#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,037 INFO L256 TraceCheckUtils]: 151: Hoare triple {14623#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,037 INFO L273 TraceCheckUtils]: 152: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,037 INFO L273 TraceCheckUtils]: 153: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,037 INFO L273 TraceCheckUtils]: 154: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,038 INFO L268 TraceCheckUtils]: 155: Hoare quadruple {14193#true} {14623#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} #97#return; {14623#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,038 INFO L256 TraceCheckUtils]: 156: Hoare triple {14623#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,038 INFO L273 TraceCheckUtils]: 157: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,038 INFO L273 TraceCheckUtils]: 158: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,038 INFO L273 TraceCheckUtils]: 159: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,039 INFO L268 TraceCheckUtils]: 160: Hoare quadruple {14193#true} {14623#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} #99#return; {14623#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,040 INFO L273 TraceCheckUtils]: 161: Hoare triple {14623#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {14687#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,040 INFO L256 TraceCheckUtils]: 162: Hoare triple {14687#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,040 INFO L273 TraceCheckUtils]: 163: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,040 INFO L273 TraceCheckUtils]: 164: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,040 INFO L273 TraceCheckUtils]: 165: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,041 INFO L268 TraceCheckUtils]: 166: Hoare quadruple {14193#true} {14687#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} #101#return; {14687#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,041 INFO L256 TraceCheckUtils]: 167: Hoare triple {14687#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,041 INFO L273 TraceCheckUtils]: 168: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,041 INFO L273 TraceCheckUtils]: 169: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,041 INFO L273 TraceCheckUtils]: 170: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,042 INFO L268 TraceCheckUtils]: 171: Hoare quadruple {14193#true} {14687#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} #103#return; {14687#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,042 INFO L273 TraceCheckUtils]: 172: Hoare triple {14687#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {14721#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:33:50,043 INFO L273 TraceCheckUtils]: 173: Hoare triple {14721#(= (_ bv7 32) main_~j~0)} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {14721#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:33:50,043 INFO L273 TraceCheckUtils]: 174: Hoare triple {14721#(= (_ bv7 32) main_~j~0)} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {14721#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:33:50,043 INFO L256 TraceCheckUtils]: 175: Hoare triple {14721#(= (_ bv7 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,044 INFO L273 TraceCheckUtils]: 176: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,044 INFO L273 TraceCheckUtils]: 177: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,044 INFO L273 TraceCheckUtils]: 178: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,045 INFO L268 TraceCheckUtils]: 179: Hoare quadruple {14193#true} {14721#(= (_ bv7 32) main_~j~0)} #81#return; {14721#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:33:50,045 INFO L256 TraceCheckUtils]: 180: Hoare triple {14721#(= (_ bv7 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,045 INFO L273 TraceCheckUtils]: 181: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,045 INFO L273 TraceCheckUtils]: 182: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,046 INFO L273 TraceCheckUtils]: 183: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,046 INFO L268 TraceCheckUtils]: 184: Hoare quadruple {14193#true} {14721#(= (_ bv7 32) main_~j~0)} #83#return; {14721#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:33:50,047 INFO L273 TraceCheckUtils]: 185: Hoare triple {14721#(= (_ bv7 32) main_~j~0)} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {14721#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:33:50,047 INFO L256 TraceCheckUtils]: 186: Hoare triple {14721#(= (_ bv7 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,047 INFO L273 TraceCheckUtils]: 187: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,047 INFO L273 TraceCheckUtils]: 188: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,048 INFO L273 TraceCheckUtils]: 189: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,048 INFO L268 TraceCheckUtils]: 190: Hoare quadruple {14193#true} {14721#(= (_ bv7 32) main_~j~0)} #85#return; {14721#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:33:50,049 INFO L256 TraceCheckUtils]: 191: Hoare triple {14721#(= (_ bv7 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,049 INFO L273 TraceCheckUtils]: 192: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,049 INFO L273 TraceCheckUtils]: 193: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,049 INFO L273 TraceCheckUtils]: 194: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,050 INFO L268 TraceCheckUtils]: 195: Hoare quadruple {14193#true} {14721#(= (_ bv7 32) main_~j~0)} #87#return; {14721#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:33:50,050 INFO L256 TraceCheckUtils]: 196: Hoare triple {14721#(= (_ bv7 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,050 INFO L273 TraceCheckUtils]: 197: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,051 INFO L273 TraceCheckUtils]: 198: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,051 INFO L273 TraceCheckUtils]: 199: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,051 INFO L268 TraceCheckUtils]: 200: Hoare quadruple {14193#true} {14721#(= (_ bv7 32) main_~j~0)} #89#return; {14721#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:33:50,052 INFO L256 TraceCheckUtils]: 201: Hoare triple {14721#(= (_ bv7 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,052 INFO L273 TraceCheckUtils]: 202: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,052 INFO L273 TraceCheckUtils]: 203: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,052 INFO L273 TraceCheckUtils]: 204: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,052 INFO L268 TraceCheckUtils]: 205: Hoare quadruple {14193#true} {14721#(= (_ bv7 32) main_~j~0)} #91#return; {14721#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:33:50,053 INFO L273 TraceCheckUtils]: 206: Hoare triple {14721#(= (_ bv7 32) main_~j~0)} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {14824#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,053 INFO L256 TraceCheckUtils]: 207: Hoare triple {14824#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,053 INFO L273 TraceCheckUtils]: 208: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,053 INFO L273 TraceCheckUtils]: 209: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,053 INFO L273 TraceCheckUtils]: 210: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,054 INFO L268 TraceCheckUtils]: 211: Hoare quadruple {14193#true} {14824#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} #93#return; {14824#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,054 INFO L256 TraceCheckUtils]: 212: Hoare triple {14824#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,054 INFO L273 TraceCheckUtils]: 213: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,054 INFO L273 TraceCheckUtils]: 214: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,054 INFO L273 TraceCheckUtils]: 215: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,055 INFO L268 TraceCheckUtils]: 216: Hoare quadruple {14193#true} {14824#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} #95#return; {14824#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,055 INFO L256 TraceCheckUtils]: 217: Hoare triple {14824#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,055 INFO L273 TraceCheckUtils]: 218: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,055 INFO L273 TraceCheckUtils]: 219: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,055 INFO L273 TraceCheckUtils]: 220: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,056 INFO L268 TraceCheckUtils]: 221: Hoare quadruple {14193#true} {14824#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} #97#return; {14824#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,056 INFO L256 TraceCheckUtils]: 222: Hoare triple {14824#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,056 INFO L273 TraceCheckUtils]: 223: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,056 INFO L273 TraceCheckUtils]: 224: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,056 INFO L273 TraceCheckUtils]: 225: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,056 INFO L268 TraceCheckUtils]: 226: Hoare quadruple {14193#true} {14824#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} #99#return; {14824#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,058 INFO L273 TraceCheckUtils]: 227: Hoare triple {14824#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {14888#(= (_ bv9 32) main_~j~0)} is VALID [2018-11-23 11:33:50,058 INFO L256 TraceCheckUtils]: 228: Hoare triple {14888#(= (_ bv9 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,058 INFO L273 TraceCheckUtils]: 229: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,058 INFO L273 TraceCheckUtils]: 230: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,058 INFO L273 TraceCheckUtils]: 231: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,059 INFO L268 TraceCheckUtils]: 232: Hoare quadruple {14193#true} {14888#(= (_ bv9 32) main_~j~0)} #101#return; {14888#(= (_ bv9 32) main_~j~0)} is VALID [2018-11-23 11:33:50,059 INFO L256 TraceCheckUtils]: 233: Hoare triple {14888#(= (_ bv9 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,059 INFO L273 TraceCheckUtils]: 234: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,059 INFO L273 TraceCheckUtils]: 235: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,059 INFO L273 TraceCheckUtils]: 236: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,060 INFO L268 TraceCheckUtils]: 237: Hoare quadruple {14193#true} {14888#(= (_ bv9 32) main_~j~0)} #103#return; {14888#(= (_ bv9 32) main_~j~0)} is VALID [2018-11-23 11:33:50,060 INFO L273 TraceCheckUtils]: 238: Hoare triple {14888#(= (_ bv9 32) main_~j~0)} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,060 INFO L273 TraceCheckUtils]: 239: Hoare triple {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,061 INFO L273 TraceCheckUtils]: 240: Hoare triple {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,061 INFO L256 TraceCheckUtils]: 241: Hoare triple {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,061 INFO L273 TraceCheckUtils]: 242: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,061 INFO L273 TraceCheckUtils]: 243: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,061 INFO L273 TraceCheckUtils]: 244: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,062 INFO L268 TraceCheckUtils]: 245: Hoare quadruple {14193#true} {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} #105#return; {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,062 INFO L256 TraceCheckUtils]: 246: Hoare triple {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,062 INFO L273 TraceCheckUtils]: 247: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,062 INFO L273 TraceCheckUtils]: 248: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,062 INFO L273 TraceCheckUtils]: 249: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,062 INFO L268 TraceCheckUtils]: 250: Hoare quadruple {14193#true} {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} #107#return; {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,063 INFO L256 TraceCheckUtils]: 251: Hoare triple {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:50,063 INFO L273 TraceCheckUtils]: 252: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:50,063 INFO L273 TraceCheckUtils]: 253: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:50,063 INFO L273 TraceCheckUtils]: 254: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:50,063 INFO L268 TraceCheckUtils]: 255: Hoare quadruple {14193#true} {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} #109#return; {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,064 INFO L256 TraceCheckUtils]: 256: Hoare triple {14922#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14977#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,066 INFO L273 TraceCheckUtils]: 257: Hoare triple {14977#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} ~cond := #in~cond; {14981#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:33:50,067 INFO L273 TraceCheckUtils]: 258: Hoare triple {14981#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} assume 0bv32 == ~cond; {14194#false} is VALID [2018-11-23 11:33:50,067 INFO L273 TraceCheckUtils]: 259: Hoare triple {14194#false} assume !false; {14194#false} is VALID [2018-11-23 11:33:50,104 INFO L134 CoverageAnalysis]: Checked inductivity of 4131 backedges. 90 proven. 81 refuted. 0 times theorem prover too weak. 3960 trivial. 0 not checked. [2018-11-23 11:33:50,104 INFO L316 TraceCheckSpWp]: Computing backward predicates... [2018-11-23 11:33:51,136 INFO L273 TraceCheckUtils]: 259: Hoare triple {14194#false} assume !false; {14194#false} is VALID [2018-11-23 11:33:51,137 INFO L273 TraceCheckUtils]: 258: Hoare triple {14991#(not (= (_ bv0 32) __VERIFIER_assert_~cond))} assume 0bv32 == ~cond; {14194#false} is VALID [2018-11-23 11:33:51,138 INFO L273 TraceCheckUtils]: 257: Hoare triple {14995#(not (= |__VERIFIER_assert_#in~cond| (_ bv0 32)))} ~cond := #in~cond; {14991#(not (= (_ bv0 32) __VERIFIER_assert_~cond))} is VALID [2018-11-23 11:33:51,138 INFO L256 TraceCheckUtils]: 256: Hoare triple {14999#(bvsle (_ bv0 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14995#(not (= |__VERIFIER_assert_#in~cond| (_ bv0 32)))} is VALID [2018-11-23 11:33:51,138 INFO L268 TraceCheckUtils]: 255: Hoare quadruple {14193#true} {14999#(bvsle (_ bv0 32) main_~j~0)} #109#return; {14999#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:33:51,139 INFO L273 TraceCheckUtils]: 254: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,139 INFO L273 TraceCheckUtils]: 253: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,139 INFO L273 TraceCheckUtils]: 252: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,139 INFO L256 TraceCheckUtils]: 251: Hoare triple {14999#(bvsle (_ bv0 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,139 INFO L268 TraceCheckUtils]: 250: Hoare quadruple {14193#true} {14999#(bvsle (_ bv0 32) main_~j~0)} #107#return; {14999#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:33:51,140 INFO L273 TraceCheckUtils]: 249: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,140 INFO L273 TraceCheckUtils]: 248: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,140 INFO L273 TraceCheckUtils]: 247: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,140 INFO L256 TraceCheckUtils]: 246: Hoare triple {14999#(bvsle (_ bv0 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,160 INFO L268 TraceCheckUtils]: 245: Hoare quadruple {14193#true} {14999#(bvsle (_ bv0 32) main_~j~0)} #105#return; {14999#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:33:51,161 INFO L273 TraceCheckUtils]: 244: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,161 INFO L273 TraceCheckUtils]: 243: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,161 INFO L273 TraceCheckUtils]: 242: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,161 INFO L256 TraceCheckUtils]: 241: Hoare triple {14999#(bvsle (_ bv0 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,161 INFO L273 TraceCheckUtils]: 240: Hoare triple {14999#(bvsle (_ bv0 32) main_~j~0)} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {14999#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:33:51,162 INFO L273 TraceCheckUtils]: 239: Hoare triple {14999#(bvsle (_ bv0 32) main_~j~0)} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {14999#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:33:51,162 INFO L273 TraceCheckUtils]: 238: Hoare triple {15054#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {14999#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:33:51,163 INFO L268 TraceCheckUtils]: 237: Hoare quadruple {14193#true} {15054#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} #103#return; {15054#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:51,163 INFO L273 TraceCheckUtils]: 236: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,163 INFO L273 TraceCheckUtils]: 235: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,163 INFO L273 TraceCheckUtils]: 234: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,163 INFO L256 TraceCheckUtils]: 233: Hoare triple {15054#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,164 INFO L268 TraceCheckUtils]: 232: Hoare quadruple {14193#true} {15054#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} #101#return; {15054#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:51,164 INFO L273 TraceCheckUtils]: 231: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,164 INFO L273 TraceCheckUtils]: 230: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,164 INFO L273 TraceCheckUtils]: 229: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,164 INFO L256 TraceCheckUtils]: 228: Hoare triple {15054#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,167 INFO L273 TraceCheckUtils]: 227: Hoare triple {15088#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {15054#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:33:51,167 INFO L268 TraceCheckUtils]: 226: Hoare quadruple {14193#true} {15088#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} #99#return; {15088#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:51,167 INFO L273 TraceCheckUtils]: 225: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,168 INFO L273 TraceCheckUtils]: 224: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,168 INFO L273 TraceCheckUtils]: 223: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,168 INFO L256 TraceCheckUtils]: 222: Hoare triple {15088#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,169 INFO L268 TraceCheckUtils]: 221: Hoare quadruple {14193#true} {15088#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} #97#return; {15088#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:51,169 INFO L273 TraceCheckUtils]: 220: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,169 INFO L273 TraceCheckUtils]: 219: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,169 INFO L273 TraceCheckUtils]: 218: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,170 INFO L256 TraceCheckUtils]: 217: Hoare triple {15088#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,170 INFO L268 TraceCheckUtils]: 216: Hoare quadruple {14193#true} {15088#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} #95#return; {15088#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:51,170 INFO L273 TraceCheckUtils]: 215: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,171 INFO L273 TraceCheckUtils]: 214: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,171 INFO L273 TraceCheckUtils]: 213: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,171 INFO L256 TraceCheckUtils]: 212: Hoare triple {15088#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,171 INFO L268 TraceCheckUtils]: 211: Hoare quadruple {14193#true} {15088#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} #93#return; {15088#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:51,171 INFO L273 TraceCheckUtils]: 210: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,172 INFO L273 TraceCheckUtils]: 209: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,172 INFO L273 TraceCheckUtils]: 208: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,172 INFO L256 TraceCheckUtils]: 207: Hoare triple {15088#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,175 INFO L273 TraceCheckUtils]: 206: Hoare triple {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {15088#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} is VALID [2018-11-23 11:33:51,175 INFO L268 TraceCheckUtils]: 205: Hoare quadruple {14193#true} {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #91#return; {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:51,176 INFO L273 TraceCheckUtils]: 204: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,176 INFO L273 TraceCheckUtils]: 203: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,176 INFO L273 TraceCheckUtils]: 202: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,176 INFO L256 TraceCheckUtils]: 201: Hoare triple {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,176 INFO L268 TraceCheckUtils]: 200: Hoare quadruple {14193#true} {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #89#return; {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:51,176 INFO L273 TraceCheckUtils]: 199: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,177 INFO L273 TraceCheckUtils]: 198: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,177 INFO L273 TraceCheckUtils]: 197: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,177 INFO L256 TraceCheckUtils]: 196: Hoare triple {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,177 INFO L268 TraceCheckUtils]: 195: Hoare quadruple {14193#true} {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #87#return; {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:51,177 INFO L273 TraceCheckUtils]: 194: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,177 INFO L273 TraceCheckUtils]: 193: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,178 INFO L273 TraceCheckUtils]: 192: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,178 INFO L256 TraceCheckUtils]: 191: Hoare triple {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,178 INFO L268 TraceCheckUtils]: 190: Hoare quadruple {14193#true} {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #85#return; {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:51,178 INFO L273 TraceCheckUtils]: 189: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,178 INFO L273 TraceCheckUtils]: 188: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,179 INFO L273 TraceCheckUtils]: 187: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,179 INFO L256 TraceCheckUtils]: 186: Hoare triple {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,179 INFO L273 TraceCheckUtils]: 185: Hoare triple {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:51,180 INFO L268 TraceCheckUtils]: 184: Hoare quadruple {14193#true} {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #83#return; {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:51,180 INFO L273 TraceCheckUtils]: 183: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,181 INFO L273 TraceCheckUtils]: 182: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,181 INFO L273 TraceCheckUtils]: 181: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,181 INFO L256 TraceCheckUtils]: 180: Hoare triple {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,182 INFO L268 TraceCheckUtils]: 179: Hoare quadruple {14193#true} {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #81#return; {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:51,182 INFO L273 TraceCheckUtils]: 178: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,182 INFO L273 TraceCheckUtils]: 177: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,182 INFO L273 TraceCheckUtils]: 176: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,183 INFO L256 TraceCheckUtils]: 175: Hoare triple {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,183 INFO L273 TraceCheckUtils]: 174: Hoare triple {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:51,184 INFO L273 TraceCheckUtils]: 173: Hoare triple {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:51,186 INFO L273 TraceCheckUtils]: 172: Hoare triple {15255#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {15152#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:33:51,187 INFO L268 TraceCheckUtils]: 171: Hoare quadruple {14193#true} {15255#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} #103#return; {15255#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:33:51,187 INFO L273 TraceCheckUtils]: 170: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,187 INFO L273 TraceCheckUtils]: 169: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,188 INFO L273 TraceCheckUtils]: 168: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,188 INFO L256 TraceCheckUtils]: 167: Hoare triple {15255#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,189 INFO L268 TraceCheckUtils]: 166: Hoare quadruple {14193#true} {15255#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} #101#return; {15255#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:33:51,189 INFO L273 TraceCheckUtils]: 165: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,189 INFO L273 TraceCheckUtils]: 164: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,189 INFO L273 TraceCheckUtils]: 163: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,189 INFO L256 TraceCheckUtils]: 162: Hoare triple {15255#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,194 INFO L273 TraceCheckUtils]: 161: Hoare triple {15289#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {15255#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:33:51,195 INFO L268 TraceCheckUtils]: 160: Hoare quadruple {14193#true} {15289#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} #99#return; {15289#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} is VALID [2018-11-23 11:33:51,195 INFO L273 TraceCheckUtils]: 159: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,195 INFO L273 TraceCheckUtils]: 158: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,195 INFO L273 TraceCheckUtils]: 157: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,196 INFO L256 TraceCheckUtils]: 156: Hoare triple {15289#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,196 INFO L268 TraceCheckUtils]: 155: Hoare quadruple {14193#true} {15289#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} #97#return; {15289#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} is VALID [2018-11-23 11:33:51,196 INFO L273 TraceCheckUtils]: 154: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,196 INFO L273 TraceCheckUtils]: 153: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,196 INFO L273 TraceCheckUtils]: 152: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,196 INFO L256 TraceCheckUtils]: 151: Hoare triple {15289#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,197 INFO L268 TraceCheckUtils]: 150: Hoare quadruple {14193#true} {15289#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} #95#return; {15289#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} is VALID [2018-11-23 11:33:51,197 INFO L273 TraceCheckUtils]: 149: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,197 INFO L273 TraceCheckUtils]: 148: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,197 INFO L273 TraceCheckUtils]: 147: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,197 INFO L256 TraceCheckUtils]: 146: Hoare triple {15289#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,198 INFO L268 TraceCheckUtils]: 145: Hoare quadruple {14193#true} {15289#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} #93#return; {15289#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} is VALID [2018-11-23 11:33:51,198 INFO L273 TraceCheckUtils]: 144: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,199 INFO L273 TraceCheckUtils]: 143: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,199 INFO L273 TraceCheckUtils]: 142: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,199 INFO L256 TraceCheckUtils]: 141: Hoare triple {15289#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,202 INFO L273 TraceCheckUtils]: 140: Hoare triple {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {15289#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} is VALID [2018-11-23 11:33:51,203 INFO L268 TraceCheckUtils]: 139: Hoare quadruple {14193#true} {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} #91#return; {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:33:51,203 INFO L273 TraceCheckUtils]: 138: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,203 INFO L273 TraceCheckUtils]: 137: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,203 INFO L273 TraceCheckUtils]: 136: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,204 INFO L256 TraceCheckUtils]: 135: Hoare triple {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,204 INFO L268 TraceCheckUtils]: 134: Hoare quadruple {14193#true} {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} #89#return; {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:33:51,204 INFO L273 TraceCheckUtils]: 133: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,205 INFO L273 TraceCheckUtils]: 132: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,205 INFO L273 TraceCheckUtils]: 131: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,205 INFO L256 TraceCheckUtils]: 130: Hoare triple {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,206 INFO L268 TraceCheckUtils]: 129: Hoare quadruple {14193#true} {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} #87#return; {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:33:51,206 INFO L273 TraceCheckUtils]: 128: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,206 INFO L273 TraceCheckUtils]: 127: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,206 INFO L273 TraceCheckUtils]: 126: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,207 INFO L256 TraceCheckUtils]: 125: Hoare triple {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,207 INFO L268 TraceCheckUtils]: 124: Hoare quadruple {14193#true} {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} #85#return; {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:33:51,207 INFO L273 TraceCheckUtils]: 123: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,207 INFO L273 TraceCheckUtils]: 122: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,207 INFO L273 TraceCheckUtils]: 121: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,208 INFO L256 TraceCheckUtils]: 120: Hoare triple {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,208 INFO L273 TraceCheckUtils]: 119: Hoare triple {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:33:51,208 INFO L268 TraceCheckUtils]: 118: Hoare quadruple {14193#true} {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} #83#return; {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:33:51,208 INFO L273 TraceCheckUtils]: 117: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,209 INFO L273 TraceCheckUtils]: 116: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,209 INFO L273 TraceCheckUtils]: 115: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,209 INFO L256 TraceCheckUtils]: 114: Hoare triple {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,210 INFO L268 TraceCheckUtils]: 113: Hoare quadruple {14193#true} {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} #81#return; {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:33:51,210 INFO L273 TraceCheckUtils]: 112: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,210 INFO L273 TraceCheckUtils]: 111: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,210 INFO L273 TraceCheckUtils]: 110: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,211 INFO L256 TraceCheckUtils]: 109: Hoare triple {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,211 INFO L273 TraceCheckUtils]: 108: Hoare triple {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:33:51,212 INFO L273 TraceCheckUtils]: 107: Hoare triple {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:33:51,215 INFO L273 TraceCheckUtils]: 106: Hoare triple {15456#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {15353#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:33:51,216 INFO L268 TraceCheckUtils]: 105: Hoare quadruple {14193#true} {15456#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} #103#return; {15456#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} is VALID [2018-11-23 11:33:51,216 INFO L273 TraceCheckUtils]: 104: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,216 INFO L273 TraceCheckUtils]: 103: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,216 INFO L273 TraceCheckUtils]: 102: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,216 INFO L256 TraceCheckUtils]: 101: Hoare triple {15456#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,217 INFO L268 TraceCheckUtils]: 100: Hoare quadruple {14193#true} {15456#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} #101#return; {15456#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} is VALID [2018-11-23 11:33:51,217 INFO L273 TraceCheckUtils]: 99: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,217 INFO L273 TraceCheckUtils]: 98: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,217 INFO L273 TraceCheckUtils]: 97: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,217 INFO L256 TraceCheckUtils]: 96: Hoare triple {15456#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,221 INFO L273 TraceCheckUtils]: 95: Hoare triple {15490#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {15456#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} is VALID [2018-11-23 11:33:51,222 INFO L268 TraceCheckUtils]: 94: Hoare quadruple {14193#true} {15490#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} #99#return; {15490#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} is VALID [2018-11-23 11:33:51,222 INFO L273 TraceCheckUtils]: 93: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,222 INFO L273 TraceCheckUtils]: 92: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,222 INFO L273 TraceCheckUtils]: 91: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,223 INFO L256 TraceCheckUtils]: 90: Hoare triple {15490#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,223 INFO L268 TraceCheckUtils]: 89: Hoare quadruple {14193#true} {15490#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} #97#return; {15490#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} is VALID [2018-11-23 11:33:51,223 INFO L273 TraceCheckUtils]: 88: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,223 INFO L273 TraceCheckUtils]: 87: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,223 INFO L273 TraceCheckUtils]: 86: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,223 INFO L256 TraceCheckUtils]: 85: Hoare triple {15490#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,224 INFO L268 TraceCheckUtils]: 84: Hoare quadruple {14193#true} {15490#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} #95#return; {15490#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} is VALID [2018-11-23 11:33:51,224 INFO L273 TraceCheckUtils]: 83: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,224 INFO L273 TraceCheckUtils]: 82: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,224 INFO L273 TraceCheckUtils]: 81: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,224 INFO L256 TraceCheckUtils]: 80: Hoare triple {15490#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,225 INFO L268 TraceCheckUtils]: 79: Hoare quadruple {14193#true} {15490#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} #93#return; {15490#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} is VALID [2018-11-23 11:33:51,225 INFO L273 TraceCheckUtils]: 78: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,225 INFO L273 TraceCheckUtils]: 77: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,226 INFO L273 TraceCheckUtils]: 76: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,226 INFO L256 TraceCheckUtils]: 75: Hoare triple {15490#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,229 INFO L273 TraceCheckUtils]: 74: Hoare triple {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {15490#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} is VALID [2018-11-23 11:33:51,230 INFO L268 TraceCheckUtils]: 73: Hoare quadruple {14193#true} {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} #91#return; {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:33:51,230 INFO L273 TraceCheckUtils]: 72: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,230 INFO L273 TraceCheckUtils]: 71: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,230 INFO L273 TraceCheckUtils]: 70: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,230 INFO L256 TraceCheckUtils]: 69: Hoare triple {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,231 INFO L268 TraceCheckUtils]: 68: Hoare quadruple {14193#true} {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} #89#return; {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:33:51,231 INFO L273 TraceCheckUtils]: 67: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,232 INFO L273 TraceCheckUtils]: 66: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,232 INFO L273 TraceCheckUtils]: 65: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,232 INFO L256 TraceCheckUtils]: 64: Hoare triple {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,233 INFO L268 TraceCheckUtils]: 63: Hoare quadruple {14193#true} {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} #87#return; {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:33:51,233 INFO L273 TraceCheckUtils]: 62: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,233 INFO L273 TraceCheckUtils]: 61: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,234 INFO L273 TraceCheckUtils]: 60: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,234 INFO L256 TraceCheckUtils]: 59: Hoare triple {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,235 INFO L268 TraceCheckUtils]: 58: Hoare quadruple {14193#true} {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} #85#return; {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:33:51,235 INFO L273 TraceCheckUtils]: 57: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,235 INFO L273 TraceCheckUtils]: 56: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,235 INFO L273 TraceCheckUtils]: 55: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,235 INFO L256 TraceCheckUtils]: 54: Hoare triple {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,236 INFO L273 TraceCheckUtils]: 53: Hoare triple {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:33:51,236 INFO L268 TraceCheckUtils]: 52: Hoare quadruple {14193#true} {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} #83#return; {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:33:51,236 INFO L273 TraceCheckUtils]: 51: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,236 INFO L273 TraceCheckUtils]: 50: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,236 INFO L273 TraceCheckUtils]: 49: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,236 INFO L256 TraceCheckUtils]: 48: Hoare triple {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,237 INFO L268 TraceCheckUtils]: 47: Hoare quadruple {14193#true} {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} #81#return; {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:33:51,237 INFO L273 TraceCheckUtils]: 46: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,237 INFO L273 TraceCheckUtils]: 45: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,237 INFO L273 TraceCheckUtils]: 44: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,237 INFO L256 TraceCheckUtils]: 43: Hoare triple {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,238 INFO L273 TraceCheckUtils]: 42: Hoare triple {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:33:51,238 INFO L273 TraceCheckUtils]: 41: Hoare triple {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:33:51,242 INFO L273 TraceCheckUtils]: 40: Hoare triple {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} #t~post9 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post9);havoc #t~post9;#t~post10 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post10);havoc #t~post10; {15554#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:33:51,243 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {14193#true} {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} #111#return; {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} is VALID [2018-11-23 11:33:51,243 INFO L273 TraceCheckUtils]: 38: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,243 INFO L273 TraceCheckUtils]: 37: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,244 INFO L273 TraceCheckUtils]: 36: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,244 INFO L256 TraceCheckUtils]: 35: Hoare triple {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,244 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {14193#true} {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} #109#return; {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} is VALID [2018-11-23 11:33:51,244 INFO L273 TraceCheckUtils]: 33: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,244 INFO L273 TraceCheckUtils]: 32: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,244 INFO L273 TraceCheckUtils]: 31: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,245 INFO L256 TraceCheckUtils]: 30: Hoare triple {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,245 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {14193#true} {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} #107#return; {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} is VALID [2018-11-23 11:33:51,246 INFO L273 TraceCheckUtils]: 28: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,246 INFO L273 TraceCheckUtils]: 27: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,246 INFO L273 TraceCheckUtils]: 26: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,246 INFO L256 TraceCheckUtils]: 25: Hoare triple {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,247 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {14193#true} {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} #105#return; {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} is VALID [2018-11-23 11:33:51,247 INFO L273 TraceCheckUtils]: 23: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,247 INFO L273 TraceCheckUtils]: 22: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,248 INFO L273 TraceCheckUtils]: 21: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,248 INFO L256 TraceCheckUtils]: 20: Hoare triple {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,248 INFO L273 TraceCheckUtils]: 19: Hoare triple {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} assume 0bv32 != #t~nondet3;havoc #t~nondet3; {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} is VALID [2018-11-23 11:33:51,248 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {14193#true} {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} #83#return; {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} is VALID [2018-11-23 11:33:51,249 INFO L273 TraceCheckUtils]: 17: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,249 INFO L273 TraceCheckUtils]: 16: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,249 INFO L273 TraceCheckUtils]: 15: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,249 INFO L256 TraceCheckUtils]: 14: Hoare triple {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,249 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {14193#true} {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} #81#return; {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} is VALID [2018-11-23 11:33:51,250 INFO L273 TraceCheckUtils]: 12: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,250 INFO L273 TraceCheckUtils]: 11: Hoare triple {14193#true} assume !(0bv32 == ~cond); {14193#true} is VALID [2018-11-23 11:33:51,250 INFO L273 TraceCheckUtils]: 10: Hoare triple {14193#true} ~cond := #in~cond; {14193#true} is VALID [2018-11-23 11:33:51,250 INFO L256 TraceCheckUtils]: 9: Hoare triple {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {14193#true} is VALID [2018-11-23 11:33:51,251 INFO L273 TraceCheckUtils]: 8: Hoare triple {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} is VALID [2018-11-23 11:33:51,251 INFO L273 TraceCheckUtils]: 7: Hoare triple {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} is VALID [2018-11-23 11:33:51,252 INFO L273 TraceCheckUtils]: 6: Hoare triple {14193#true} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {15657#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} is VALID [2018-11-23 11:33:51,252 INFO L273 TraceCheckUtils]: 5: Hoare triple {14193#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {14193#true} is VALID [2018-11-23 11:33:51,252 INFO L273 TraceCheckUtils]: 4: Hoare triple {14193#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {14193#true} is VALID [2018-11-23 11:33:51,252 INFO L256 TraceCheckUtils]: 3: Hoare triple {14193#true} call #t~ret11 := main(); {14193#true} is VALID [2018-11-23 11:33:51,253 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {14193#true} {14193#true} #77#return; {14193#true} is VALID [2018-11-23 11:33:51,253 INFO L273 TraceCheckUtils]: 1: Hoare triple {14193#true} assume true; {14193#true} is VALID [2018-11-23 11:33:51,253 INFO L256 TraceCheckUtils]: 0: Hoare triple {14193#true} call ULTIMATE.init(); {14193#true} is VALID [2018-11-23 11:33:51,292 INFO L134 CoverageAnalysis]: Checked inductivity of 4131 backedges. 90 proven. 81 refuted. 0 times theorem prover too weak. 3960 trivial. 0 not checked. [2018-11-23 11:33:51,294 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 11:33:51,295 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [15, 15] total 28 [2018-11-23 11:33:51,296 INFO L78 Accepts]: Start accepts. Automaton has 28 states. Word has length 260 [2018-11-23 11:33:51,297 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 11:33:51,297 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 28 states. [2018-11-23 11:33:51,713 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 246 edges. 246 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:33:51,714 INFO L459 AbstractCegarLoop]: Interpolant automaton has 28 states [2018-11-23 11:33:51,714 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 28 interpolants. [2018-11-23 11:33:51,715 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=176, Invalid=580, Unknown=0, NotChecked=0, Total=756 [2018-11-23 11:33:51,715 INFO L87 Difference]: Start difference. First operand 381 states and 595 transitions. Second operand 28 states. [2018-11-23 11:34:42,164 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:34:42,164 INFO L93 Difference]: Finished difference Result 964 states and 1629 transitions. [2018-11-23 11:34:42,165 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 27 states. [2018-11-23 11:34:42,165 INFO L78 Accepts]: Start accepts. Automaton has 28 states. Word has length 260 [2018-11-23 11:34:42,165 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 11:34:42,166 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 28 states. [2018-11-23 11:34:42,221 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 27 states to 27 states and 950 transitions. [2018-11-23 11:34:42,221 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 28 states. [2018-11-23 11:34:42,280 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 27 states to 27 states and 950 transitions. [2018-11-23 11:34:42,280 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 27 states and 950 transitions. [2018-11-23 11:34:44,264 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 950 edges. 950 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:34:44,322 INFO L225 Difference]: With dead ends: 964 [2018-11-23 11:34:44,322 INFO L226 Difference]: Without dead ends: 918 [2018-11-23 11:34:44,324 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 530 GetRequests, 493 SyntacticMatches, 0 SemanticMatches, 37 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 78 ImplicationChecksByTransitivity, 1.6s TimeCoverageRelationStatistics Valid=422, Invalid=1060, Unknown=0, NotChecked=0, Total=1482 [2018-11-23 11:34:44,325 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 918 states. [2018-11-23 11:34:48,398 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 918 to 856. [2018-11-23 11:34:48,398 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 11:34:48,399 INFO L82 GeneralOperation]: Start isEquivalent. First operand 918 states. Second operand 856 states. [2018-11-23 11:34:48,399 INFO L74 IsIncluded]: Start isIncluded. First operand 918 states. Second operand 856 states. [2018-11-23 11:34:48,399 INFO L87 Difference]: Start difference. First operand 918 states. Second operand 856 states. [2018-11-23 11:34:48,504 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:34:48,504 INFO L93 Difference]: Finished difference Result 918 states and 1539 transitions. [2018-11-23 11:34:48,504 INFO L276 IsEmpty]: Start isEmpty. Operand 918 states and 1539 transitions. [2018-11-23 11:34:48,511 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:34:48,511 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:34:48,511 INFO L74 IsIncluded]: Start isIncluded. First operand 856 states. Second operand 918 states. [2018-11-23 11:34:48,511 INFO L87 Difference]: Start difference. First operand 856 states. Second operand 918 states. [2018-11-23 11:34:48,626 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 11:34:48,626 INFO L93 Difference]: Finished difference Result 918 states and 1539 transitions. [2018-11-23 11:34:48,627 INFO L276 IsEmpty]: Start isEmpty. Operand 918 states and 1539 transitions. [2018-11-23 11:34:48,633 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 11:34:48,633 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 11:34:48,634 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 11:34:48,634 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 11:34:48,634 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 856 states. [2018-11-23 11:34:48,735 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 856 states to 856 states and 1449 transitions. [2018-11-23 11:34:48,735 INFO L78 Accepts]: Start accepts. Automaton has 856 states and 1449 transitions. Word has length 260 [2018-11-23 11:34:48,736 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 11:34:48,736 INFO L480 AbstractCegarLoop]: Abstraction has 856 states and 1449 transitions. [2018-11-23 11:34:48,736 INFO L481 AbstractCegarLoop]: Interpolant automaton has 28 states. [2018-11-23 11:34:48,736 INFO L276 IsEmpty]: Start isEmpty. Operand 856 states and 1449 transitions. [2018-11-23 11:34:48,753 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 525 [2018-11-23 11:34:48,753 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 11:34:48,754 INFO L402 BasicCegarLoop]: trace histogram [94, 93, 93, 9, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 11:34:48,754 INFO L423 AbstractCegarLoop]: === Iteration 14 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 11:34:48,754 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 11:34:48,755 INFO L82 PathProgramCache]: Analyzing trace with hash 326256885, now seen corresponding path program 2 times [2018-11-23 11:34:48,756 INFO L223 ckRefinementStrategy]: Switched to mode CVC4_FPBP [2018-11-23 11:34:48,756 INFO L69 tionRefinementEngine]: Using refinement strategy WolfRefinementStrategy No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/cvc4nyu Starting monitored process 15 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 15 with cvc4nyu --tear-down-incremental --print-success --lang smt --rewrite-divk [2018-11-23 11:34:48,781 INFO L101 rtionOrderModulation]: Changing assertion order to OUTSIDE_LOOP_FIRST1 [2018-11-23 11:34:49,224 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 11:34:49,224 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 11:34:49,449 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 11:34:49,456 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 11:34:50,331 INFO L256 TraceCheckUtils]: 0: Hoare triple {20764#true} call ULTIMATE.init(); {20764#true} is VALID [2018-11-23 11:34:50,331 INFO L273 TraceCheckUtils]: 1: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,331 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {20764#true} {20764#true} #77#return; {20764#true} is VALID [2018-11-23 11:34:50,331 INFO L256 TraceCheckUtils]: 3: Hoare triple {20764#true} call #t~ret11 := main(); {20764#true} is VALID [2018-11-23 11:34:50,332 INFO L273 TraceCheckUtils]: 4: Hoare triple {20764#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {20764#true} is VALID [2018-11-23 11:34:50,332 INFO L273 TraceCheckUtils]: 5: Hoare triple {20764#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {20764#true} is VALID [2018-11-23 11:34:50,332 INFO L273 TraceCheckUtils]: 6: Hoare triple {20764#true} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {20787#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:34:50,333 INFO L273 TraceCheckUtils]: 7: Hoare triple {20787#(= main_~j~0 (_ bv0 32))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {20787#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:34:50,333 INFO L273 TraceCheckUtils]: 8: Hoare triple {20787#(= main_~j~0 (_ bv0 32))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {20787#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:34:50,334 INFO L256 TraceCheckUtils]: 9: Hoare triple {20787#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,334 INFO L273 TraceCheckUtils]: 10: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,334 INFO L273 TraceCheckUtils]: 11: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,334 INFO L273 TraceCheckUtils]: 12: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,334 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {20764#true} {20787#(= main_~j~0 (_ bv0 32))} #81#return; {20787#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:34:50,334 INFO L256 TraceCheckUtils]: 14: Hoare triple {20787#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,335 INFO L273 TraceCheckUtils]: 15: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,335 INFO L273 TraceCheckUtils]: 16: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,335 INFO L273 TraceCheckUtils]: 17: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,335 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {20764#true} {20787#(= main_~j~0 (_ bv0 32))} #83#return; {20787#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:34:50,336 INFO L273 TraceCheckUtils]: 19: Hoare triple {20787#(= main_~j~0 (_ bv0 32))} assume 0bv32 != #t~nondet3;havoc #t~nondet3; {20787#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:34:50,336 INFO L256 TraceCheckUtils]: 20: Hoare triple {20787#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,336 INFO L273 TraceCheckUtils]: 21: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,336 INFO L273 TraceCheckUtils]: 22: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,336 INFO L273 TraceCheckUtils]: 23: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,337 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {20764#true} {20787#(= main_~j~0 (_ bv0 32))} #105#return; {20787#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:34:50,337 INFO L256 TraceCheckUtils]: 25: Hoare triple {20787#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,337 INFO L273 TraceCheckUtils]: 26: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,337 INFO L273 TraceCheckUtils]: 27: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,337 INFO L273 TraceCheckUtils]: 28: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,338 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {20764#true} {20787#(= main_~j~0 (_ bv0 32))} #107#return; {20787#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:34:50,338 INFO L256 TraceCheckUtils]: 30: Hoare triple {20787#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,338 INFO L273 TraceCheckUtils]: 31: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,339 INFO L273 TraceCheckUtils]: 32: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,339 INFO L273 TraceCheckUtils]: 33: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,340 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {20764#true} {20787#(= main_~j~0 (_ bv0 32))} #109#return; {20787#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:34:50,340 INFO L256 TraceCheckUtils]: 35: Hoare triple {20787#(= main_~j~0 (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,340 INFO L273 TraceCheckUtils]: 36: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,340 INFO L273 TraceCheckUtils]: 37: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,340 INFO L273 TraceCheckUtils]: 38: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,341 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {20764#true} {20787#(= main_~j~0 (_ bv0 32))} #111#return; {20787#(= main_~j~0 (_ bv0 32))} is VALID [2018-11-23 11:34:50,342 INFO L273 TraceCheckUtils]: 40: Hoare triple {20787#(= main_~j~0 (_ bv0 32))} #t~post9 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post9);havoc #t~post9;#t~post10 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post10);havoc #t~post10; {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,342 INFO L273 TraceCheckUtils]: 41: Hoare triple {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,342 INFO L273 TraceCheckUtils]: 42: Hoare triple {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,342 INFO L256 TraceCheckUtils]: 43: Hoare triple {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,343 INFO L273 TraceCheckUtils]: 44: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,343 INFO L273 TraceCheckUtils]: 45: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,343 INFO L273 TraceCheckUtils]: 46: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,343 INFO L268 TraceCheckUtils]: 47: Hoare quadruple {20764#true} {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #81#return; {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,343 INFO L256 TraceCheckUtils]: 48: Hoare triple {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,343 INFO L273 TraceCheckUtils]: 49: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,344 INFO L273 TraceCheckUtils]: 50: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,344 INFO L273 TraceCheckUtils]: 51: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,344 INFO L268 TraceCheckUtils]: 52: Hoare quadruple {20764#true} {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #83#return; {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,344 INFO L273 TraceCheckUtils]: 53: Hoare triple {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,345 INFO L256 TraceCheckUtils]: 54: Hoare triple {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,345 INFO L273 TraceCheckUtils]: 55: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,345 INFO L273 TraceCheckUtils]: 56: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,345 INFO L273 TraceCheckUtils]: 57: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,346 INFO L268 TraceCheckUtils]: 58: Hoare quadruple {20764#true} {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #85#return; {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,346 INFO L256 TraceCheckUtils]: 59: Hoare triple {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,347 INFO L273 TraceCheckUtils]: 60: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,347 INFO L273 TraceCheckUtils]: 61: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,347 INFO L273 TraceCheckUtils]: 62: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,372 INFO L268 TraceCheckUtils]: 63: Hoare quadruple {20764#true} {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #87#return; {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,372 INFO L256 TraceCheckUtils]: 64: Hoare triple {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,372 INFO L273 TraceCheckUtils]: 65: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,373 INFO L273 TraceCheckUtils]: 66: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,373 INFO L273 TraceCheckUtils]: 67: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,386 INFO L268 TraceCheckUtils]: 68: Hoare quadruple {20764#true} {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #89#return; {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,386 INFO L256 TraceCheckUtils]: 69: Hoare triple {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,386 INFO L273 TraceCheckUtils]: 70: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,387 INFO L273 TraceCheckUtils]: 71: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,387 INFO L273 TraceCheckUtils]: 72: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,401 INFO L268 TraceCheckUtils]: 73: Hoare quadruple {20764#true} {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #91#return; {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,402 INFO L273 TraceCheckUtils]: 74: Hoare triple {20890#(= (bvadd main_~j~0 (_ bv4294967295 32)) (_ bv0 32))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {20993#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,402 INFO L256 TraceCheckUtils]: 75: Hoare triple {20993#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,402 INFO L273 TraceCheckUtils]: 76: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,402 INFO L273 TraceCheckUtils]: 77: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,402 INFO L273 TraceCheckUtils]: 78: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,404 INFO L268 TraceCheckUtils]: 79: Hoare quadruple {20764#true} {20993#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} #93#return; {20993#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,404 INFO L256 TraceCheckUtils]: 80: Hoare triple {20993#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,404 INFO L273 TraceCheckUtils]: 81: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,404 INFO L273 TraceCheckUtils]: 82: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,404 INFO L273 TraceCheckUtils]: 83: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,406 INFO L268 TraceCheckUtils]: 84: Hoare quadruple {20764#true} {20993#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} #95#return; {20993#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,406 INFO L256 TraceCheckUtils]: 85: Hoare triple {20993#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,406 INFO L273 TraceCheckUtils]: 86: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,406 INFO L273 TraceCheckUtils]: 87: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,407 INFO L273 TraceCheckUtils]: 88: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,407 INFO L268 TraceCheckUtils]: 89: Hoare quadruple {20764#true} {20993#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} #97#return; {20993#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,407 INFO L256 TraceCheckUtils]: 90: Hoare triple {20993#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,407 INFO L273 TraceCheckUtils]: 91: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,407 INFO L273 TraceCheckUtils]: 92: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,407 INFO L273 TraceCheckUtils]: 93: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,408 INFO L268 TraceCheckUtils]: 94: Hoare quadruple {20764#true} {20993#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} #99#return; {20993#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,409 INFO L273 TraceCheckUtils]: 95: Hoare triple {20993#(= (bvadd main_~j~0 (_ bv4294967294 32)) (_ bv0 32))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {21057#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,409 INFO L256 TraceCheckUtils]: 96: Hoare triple {21057#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,409 INFO L273 TraceCheckUtils]: 97: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,409 INFO L273 TraceCheckUtils]: 98: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,409 INFO L273 TraceCheckUtils]: 99: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,410 INFO L268 TraceCheckUtils]: 100: Hoare quadruple {20764#true} {21057#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} #101#return; {21057#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,410 INFO L256 TraceCheckUtils]: 101: Hoare triple {21057#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,410 INFO L273 TraceCheckUtils]: 102: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,410 INFO L273 TraceCheckUtils]: 103: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,410 INFO L273 TraceCheckUtils]: 104: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,411 INFO L268 TraceCheckUtils]: 105: Hoare quadruple {20764#true} {21057#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} #103#return; {21057#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,411 INFO L273 TraceCheckUtils]: 106: Hoare triple {21057#(= (bvadd main_~j~0 (_ bv4294967293 32)) (_ bv0 32))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,411 INFO L273 TraceCheckUtils]: 107: Hoare triple {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,412 INFO L273 TraceCheckUtils]: 108: Hoare triple {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,412 INFO L256 TraceCheckUtils]: 109: Hoare triple {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,412 INFO L273 TraceCheckUtils]: 110: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,412 INFO L273 TraceCheckUtils]: 111: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,412 INFO L273 TraceCheckUtils]: 112: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,413 INFO L268 TraceCheckUtils]: 113: Hoare quadruple {20764#true} {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #81#return; {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,413 INFO L256 TraceCheckUtils]: 114: Hoare triple {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,413 INFO L273 TraceCheckUtils]: 115: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,413 INFO L273 TraceCheckUtils]: 116: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,413 INFO L273 TraceCheckUtils]: 117: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,423 INFO L268 TraceCheckUtils]: 118: Hoare quadruple {20764#true} {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #83#return; {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,424 INFO L273 TraceCheckUtils]: 119: Hoare triple {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,424 INFO L256 TraceCheckUtils]: 120: Hoare triple {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,424 INFO L273 TraceCheckUtils]: 121: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,424 INFO L273 TraceCheckUtils]: 122: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,425 INFO L273 TraceCheckUtils]: 123: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,428 INFO L268 TraceCheckUtils]: 124: Hoare quadruple {20764#true} {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #85#return; {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,428 INFO L256 TraceCheckUtils]: 125: Hoare triple {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,428 INFO L273 TraceCheckUtils]: 126: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,428 INFO L273 TraceCheckUtils]: 127: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,428 INFO L273 TraceCheckUtils]: 128: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,429 INFO L268 TraceCheckUtils]: 129: Hoare quadruple {20764#true} {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #87#return; {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,429 INFO L256 TraceCheckUtils]: 130: Hoare triple {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,429 INFO L273 TraceCheckUtils]: 131: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,429 INFO L273 TraceCheckUtils]: 132: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,430 INFO L273 TraceCheckUtils]: 133: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,430 INFO L268 TraceCheckUtils]: 134: Hoare quadruple {20764#true} {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #89#return; {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,430 INFO L256 TraceCheckUtils]: 135: Hoare triple {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,430 INFO L273 TraceCheckUtils]: 136: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,430 INFO L273 TraceCheckUtils]: 137: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,430 INFO L273 TraceCheckUtils]: 138: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,431 INFO L268 TraceCheckUtils]: 139: Hoare quadruple {20764#true} {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #91#return; {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,431 INFO L273 TraceCheckUtils]: 140: Hoare triple {21091#(= (bvadd main_~j~0 (_ bv4294967292 32)) (_ bv0 32))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {21194#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,431 INFO L256 TraceCheckUtils]: 141: Hoare triple {21194#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,432 INFO L273 TraceCheckUtils]: 142: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,432 INFO L273 TraceCheckUtils]: 143: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,432 INFO L273 TraceCheckUtils]: 144: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,432 INFO L268 TraceCheckUtils]: 145: Hoare quadruple {20764#true} {21194#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} #93#return; {21194#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,432 INFO L256 TraceCheckUtils]: 146: Hoare triple {21194#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,432 INFO L273 TraceCheckUtils]: 147: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,433 INFO L273 TraceCheckUtils]: 148: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,433 INFO L273 TraceCheckUtils]: 149: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,433 INFO L268 TraceCheckUtils]: 150: Hoare quadruple {20764#true} {21194#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} #95#return; {21194#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,433 INFO L256 TraceCheckUtils]: 151: Hoare triple {21194#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,433 INFO L273 TraceCheckUtils]: 152: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,433 INFO L273 TraceCheckUtils]: 153: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,434 INFO L273 TraceCheckUtils]: 154: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,434 INFO L268 TraceCheckUtils]: 155: Hoare quadruple {20764#true} {21194#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} #97#return; {21194#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,435 INFO L256 TraceCheckUtils]: 156: Hoare triple {21194#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,435 INFO L273 TraceCheckUtils]: 157: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,435 INFO L273 TraceCheckUtils]: 158: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,435 INFO L273 TraceCheckUtils]: 159: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,436 INFO L268 TraceCheckUtils]: 160: Hoare quadruple {20764#true} {21194#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} #99#return; {21194#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,437 INFO L273 TraceCheckUtils]: 161: Hoare triple {21194#(= (bvadd main_~j~0 (_ bv4294967291 32)) (_ bv0 32))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {21258#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,437 INFO L256 TraceCheckUtils]: 162: Hoare triple {21258#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,437 INFO L273 TraceCheckUtils]: 163: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,437 INFO L273 TraceCheckUtils]: 164: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,437 INFO L273 TraceCheckUtils]: 165: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,438 INFO L268 TraceCheckUtils]: 166: Hoare quadruple {20764#true} {21258#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} #101#return; {21258#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,438 INFO L256 TraceCheckUtils]: 167: Hoare triple {21258#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,438 INFO L273 TraceCheckUtils]: 168: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,438 INFO L273 TraceCheckUtils]: 169: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,438 INFO L273 TraceCheckUtils]: 170: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,438 INFO L268 TraceCheckUtils]: 171: Hoare quadruple {20764#true} {21258#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} #103#return; {21258#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,439 INFO L273 TraceCheckUtils]: 172: Hoare triple {21258#(= (bvadd main_~j~0 (_ bv4294967290 32)) (_ bv0 32))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {21292#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:34:50,439 INFO L273 TraceCheckUtils]: 173: Hoare triple {21292#(= (_ bv7 32) main_~j~0)} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {21292#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:34:50,440 INFO L273 TraceCheckUtils]: 174: Hoare triple {21292#(= (_ bv7 32) main_~j~0)} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {21292#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:34:50,440 INFO L256 TraceCheckUtils]: 175: Hoare triple {21292#(= (_ bv7 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,440 INFO L273 TraceCheckUtils]: 176: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,440 INFO L273 TraceCheckUtils]: 177: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,440 INFO L273 TraceCheckUtils]: 178: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,440 INFO L268 TraceCheckUtils]: 179: Hoare quadruple {20764#true} {21292#(= (_ bv7 32) main_~j~0)} #81#return; {21292#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:34:50,441 INFO L256 TraceCheckUtils]: 180: Hoare triple {21292#(= (_ bv7 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,441 INFO L273 TraceCheckUtils]: 181: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,441 INFO L273 TraceCheckUtils]: 182: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,441 INFO L273 TraceCheckUtils]: 183: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,441 INFO L268 TraceCheckUtils]: 184: Hoare quadruple {20764#true} {21292#(= (_ bv7 32) main_~j~0)} #83#return; {21292#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:34:50,442 INFO L273 TraceCheckUtils]: 185: Hoare triple {21292#(= (_ bv7 32) main_~j~0)} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {21292#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:34:50,442 INFO L256 TraceCheckUtils]: 186: Hoare triple {21292#(= (_ bv7 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,442 INFO L273 TraceCheckUtils]: 187: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,442 INFO L273 TraceCheckUtils]: 188: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,442 INFO L273 TraceCheckUtils]: 189: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,442 INFO L268 TraceCheckUtils]: 190: Hoare quadruple {20764#true} {21292#(= (_ bv7 32) main_~j~0)} #85#return; {21292#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:34:50,443 INFO L256 TraceCheckUtils]: 191: Hoare triple {21292#(= (_ bv7 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,443 INFO L273 TraceCheckUtils]: 192: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,443 INFO L273 TraceCheckUtils]: 193: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,443 INFO L273 TraceCheckUtils]: 194: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,444 INFO L268 TraceCheckUtils]: 195: Hoare quadruple {20764#true} {21292#(= (_ bv7 32) main_~j~0)} #87#return; {21292#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:34:50,444 INFO L256 TraceCheckUtils]: 196: Hoare triple {21292#(= (_ bv7 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,444 INFO L273 TraceCheckUtils]: 197: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,445 INFO L273 TraceCheckUtils]: 198: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,445 INFO L273 TraceCheckUtils]: 199: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,445 INFO L268 TraceCheckUtils]: 200: Hoare quadruple {20764#true} {21292#(= (_ bv7 32) main_~j~0)} #89#return; {21292#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:34:50,446 INFO L256 TraceCheckUtils]: 201: Hoare triple {21292#(= (_ bv7 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,446 INFO L273 TraceCheckUtils]: 202: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,446 INFO L273 TraceCheckUtils]: 203: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,446 INFO L273 TraceCheckUtils]: 204: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,447 INFO L268 TraceCheckUtils]: 205: Hoare quadruple {20764#true} {21292#(= (_ bv7 32) main_~j~0)} #91#return; {21292#(= (_ bv7 32) main_~j~0)} is VALID [2018-11-23 11:34:50,448 INFO L273 TraceCheckUtils]: 206: Hoare triple {21292#(= (_ bv7 32) main_~j~0)} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {21395#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,448 INFO L256 TraceCheckUtils]: 207: Hoare triple {21395#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,448 INFO L273 TraceCheckUtils]: 208: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,448 INFO L273 TraceCheckUtils]: 209: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,448 INFO L273 TraceCheckUtils]: 210: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,449 INFO L268 TraceCheckUtils]: 211: Hoare quadruple {20764#true} {21395#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} #93#return; {21395#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,449 INFO L256 TraceCheckUtils]: 212: Hoare triple {21395#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,449 INFO L273 TraceCheckUtils]: 213: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,449 INFO L273 TraceCheckUtils]: 214: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,449 INFO L273 TraceCheckUtils]: 215: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,449 INFO L268 TraceCheckUtils]: 216: Hoare quadruple {20764#true} {21395#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} #95#return; {21395#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,450 INFO L256 TraceCheckUtils]: 217: Hoare triple {21395#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,450 INFO L273 TraceCheckUtils]: 218: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,450 INFO L273 TraceCheckUtils]: 219: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,450 INFO L273 TraceCheckUtils]: 220: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,450 INFO L268 TraceCheckUtils]: 221: Hoare quadruple {20764#true} {21395#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} #97#return; {21395#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,450 INFO L256 TraceCheckUtils]: 222: Hoare triple {21395#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,451 INFO L273 TraceCheckUtils]: 223: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,451 INFO L273 TraceCheckUtils]: 224: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,451 INFO L273 TraceCheckUtils]: 225: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,452 INFO L268 TraceCheckUtils]: 226: Hoare quadruple {20764#true} {21395#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} #99#return; {21395#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,453 INFO L273 TraceCheckUtils]: 227: Hoare triple {21395#(= (bvadd main_~j~0 (_ bv4294967288 32)) (_ bv0 32))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {21459#(= (_ bv9 32) main_~j~0)} is VALID [2018-11-23 11:34:50,453 INFO L256 TraceCheckUtils]: 228: Hoare triple {21459#(= (_ bv9 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,454 INFO L273 TraceCheckUtils]: 229: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,454 INFO L273 TraceCheckUtils]: 230: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,454 INFO L273 TraceCheckUtils]: 231: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,454 INFO L268 TraceCheckUtils]: 232: Hoare quadruple {20764#true} {21459#(= (_ bv9 32) main_~j~0)} #101#return; {21459#(= (_ bv9 32) main_~j~0)} is VALID [2018-11-23 11:34:50,454 INFO L256 TraceCheckUtils]: 233: Hoare triple {21459#(= (_ bv9 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,454 INFO L273 TraceCheckUtils]: 234: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,455 INFO L273 TraceCheckUtils]: 235: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,455 INFO L273 TraceCheckUtils]: 236: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,455 INFO L268 TraceCheckUtils]: 237: Hoare quadruple {20764#true} {21459#(= (_ bv9 32) main_~j~0)} #103#return; {21459#(= (_ bv9 32) main_~j~0)} is VALID [2018-11-23 11:34:50,455 INFO L273 TraceCheckUtils]: 238: Hoare triple {21459#(= (_ bv9 32) main_~j~0)} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,456 INFO L273 TraceCheckUtils]: 239: Hoare triple {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,456 INFO L273 TraceCheckUtils]: 240: Hoare triple {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,456 INFO L256 TraceCheckUtils]: 241: Hoare triple {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,456 INFO L273 TraceCheckUtils]: 242: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,456 INFO L273 TraceCheckUtils]: 243: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,457 INFO L273 TraceCheckUtils]: 244: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,457 INFO L268 TraceCheckUtils]: 245: Hoare quadruple {20764#true} {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} #81#return; {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,457 INFO L256 TraceCheckUtils]: 246: Hoare triple {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,457 INFO L273 TraceCheckUtils]: 247: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,457 INFO L273 TraceCheckUtils]: 248: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,457 INFO L273 TraceCheckUtils]: 249: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,458 INFO L268 TraceCheckUtils]: 250: Hoare quadruple {20764#true} {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} #83#return; {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,458 INFO L273 TraceCheckUtils]: 251: Hoare triple {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,458 INFO L256 TraceCheckUtils]: 252: Hoare triple {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,458 INFO L273 TraceCheckUtils]: 253: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,459 INFO L273 TraceCheckUtils]: 254: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,459 INFO L273 TraceCheckUtils]: 255: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,459 INFO L268 TraceCheckUtils]: 256: Hoare quadruple {20764#true} {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} #85#return; {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,460 INFO L256 TraceCheckUtils]: 257: Hoare triple {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,460 INFO L273 TraceCheckUtils]: 258: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,460 INFO L273 TraceCheckUtils]: 259: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,460 INFO L273 TraceCheckUtils]: 260: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,461 INFO L268 TraceCheckUtils]: 261: Hoare quadruple {20764#true} {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} #87#return; {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,461 INFO L256 TraceCheckUtils]: 262: Hoare triple {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,461 INFO L273 TraceCheckUtils]: 263: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,462 INFO L273 TraceCheckUtils]: 264: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,462 INFO L273 TraceCheckUtils]: 265: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,462 INFO L268 TraceCheckUtils]: 266: Hoare quadruple {20764#true} {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} #89#return; {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,463 INFO L256 TraceCheckUtils]: 267: Hoare triple {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,463 INFO L273 TraceCheckUtils]: 268: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,463 INFO L273 TraceCheckUtils]: 269: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,463 INFO L273 TraceCheckUtils]: 270: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,464 INFO L268 TraceCheckUtils]: 271: Hoare quadruple {20764#true} {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} #91#return; {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,465 INFO L273 TraceCheckUtils]: 272: Hoare triple {21493#(= (bvadd main_~j~0 (_ bv4294967286 32)) (_ bv0 32))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {21596#(= (_ bv11 32) main_~j~0)} is VALID [2018-11-23 11:34:50,465 INFO L256 TraceCheckUtils]: 273: Hoare triple {21596#(= (_ bv11 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,465 INFO L273 TraceCheckUtils]: 274: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,465 INFO L273 TraceCheckUtils]: 275: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,465 INFO L273 TraceCheckUtils]: 276: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,466 INFO L268 TraceCheckUtils]: 277: Hoare quadruple {20764#true} {21596#(= (_ bv11 32) main_~j~0)} #93#return; {21596#(= (_ bv11 32) main_~j~0)} is VALID [2018-11-23 11:34:50,466 INFO L256 TraceCheckUtils]: 278: Hoare triple {21596#(= (_ bv11 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,466 INFO L273 TraceCheckUtils]: 279: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,466 INFO L273 TraceCheckUtils]: 280: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,466 INFO L273 TraceCheckUtils]: 281: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,466 INFO L268 TraceCheckUtils]: 282: Hoare quadruple {20764#true} {21596#(= (_ bv11 32) main_~j~0)} #95#return; {21596#(= (_ bv11 32) main_~j~0)} is VALID [2018-11-23 11:34:50,467 INFO L256 TraceCheckUtils]: 283: Hoare triple {21596#(= (_ bv11 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,467 INFO L273 TraceCheckUtils]: 284: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,467 INFO L273 TraceCheckUtils]: 285: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,467 INFO L273 TraceCheckUtils]: 286: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,467 INFO L268 TraceCheckUtils]: 287: Hoare quadruple {20764#true} {21596#(= (_ bv11 32) main_~j~0)} #97#return; {21596#(= (_ bv11 32) main_~j~0)} is VALID [2018-11-23 11:34:50,467 INFO L256 TraceCheckUtils]: 288: Hoare triple {21596#(= (_ bv11 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,468 INFO L273 TraceCheckUtils]: 289: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,468 INFO L273 TraceCheckUtils]: 290: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,468 INFO L273 TraceCheckUtils]: 291: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,468 INFO L268 TraceCheckUtils]: 292: Hoare quadruple {20764#true} {21596#(= (_ bv11 32) main_~j~0)} #99#return; {21596#(= (_ bv11 32) main_~j~0)} is VALID [2018-11-23 11:34:50,469 INFO L273 TraceCheckUtils]: 293: Hoare triple {21596#(= (_ bv11 32) main_~j~0)} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {21660#(= (bvadd main_~j~0 (_ bv4294967284 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,469 INFO L256 TraceCheckUtils]: 294: Hoare triple {21660#(= (bvadd main_~j~0 (_ bv4294967284 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,470 INFO L273 TraceCheckUtils]: 295: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,470 INFO L273 TraceCheckUtils]: 296: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,470 INFO L273 TraceCheckUtils]: 297: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,471 INFO L268 TraceCheckUtils]: 298: Hoare quadruple {20764#true} {21660#(= (bvadd main_~j~0 (_ bv4294967284 32)) (_ bv0 32))} #101#return; {21660#(= (bvadd main_~j~0 (_ bv4294967284 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,471 INFO L256 TraceCheckUtils]: 299: Hoare triple {21660#(= (bvadd main_~j~0 (_ bv4294967284 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,471 INFO L273 TraceCheckUtils]: 300: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,471 INFO L273 TraceCheckUtils]: 301: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,472 INFO L273 TraceCheckUtils]: 302: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,472 INFO L268 TraceCheckUtils]: 303: Hoare quadruple {20764#true} {21660#(= (bvadd main_~j~0 (_ bv4294967284 32)) (_ bv0 32))} #103#return; {21660#(= (bvadd main_~j~0 (_ bv4294967284 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,473 INFO L273 TraceCheckUtils]: 304: Hoare triple {21660#(= (bvadd main_~j~0 (_ bv4294967284 32)) (_ bv0 32))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {21694#(= (_ bv13 32) main_~j~0)} is VALID [2018-11-23 11:34:50,473 INFO L273 TraceCheckUtils]: 305: Hoare triple {21694#(= (_ bv13 32) main_~j~0)} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {21694#(= (_ bv13 32) main_~j~0)} is VALID [2018-11-23 11:34:50,473 INFO L273 TraceCheckUtils]: 306: Hoare triple {21694#(= (_ bv13 32) main_~j~0)} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {21694#(= (_ bv13 32) main_~j~0)} is VALID [2018-11-23 11:34:50,474 INFO L256 TraceCheckUtils]: 307: Hoare triple {21694#(= (_ bv13 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,474 INFO L273 TraceCheckUtils]: 308: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,474 INFO L273 TraceCheckUtils]: 309: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,474 INFO L273 TraceCheckUtils]: 310: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,474 INFO L268 TraceCheckUtils]: 311: Hoare quadruple {20764#true} {21694#(= (_ bv13 32) main_~j~0)} #81#return; {21694#(= (_ bv13 32) main_~j~0)} is VALID [2018-11-23 11:34:50,474 INFO L256 TraceCheckUtils]: 312: Hoare triple {21694#(= (_ bv13 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,475 INFO L273 TraceCheckUtils]: 313: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,475 INFO L273 TraceCheckUtils]: 314: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,475 INFO L273 TraceCheckUtils]: 315: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,475 INFO L268 TraceCheckUtils]: 316: Hoare quadruple {20764#true} {21694#(= (_ bv13 32) main_~j~0)} #83#return; {21694#(= (_ bv13 32) main_~j~0)} is VALID [2018-11-23 11:34:50,475 INFO L273 TraceCheckUtils]: 317: Hoare triple {21694#(= (_ bv13 32) main_~j~0)} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {21694#(= (_ bv13 32) main_~j~0)} is VALID [2018-11-23 11:34:50,476 INFO L256 TraceCheckUtils]: 318: Hoare triple {21694#(= (_ bv13 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,476 INFO L273 TraceCheckUtils]: 319: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,476 INFO L273 TraceCheckUtils]: 320: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,476 INFO L273 TraceCheckUtils]: 321: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,477 INFO L268 TraceCheckUtils]: 322: Hoare quadruple {20764#true} {21694#(= (_ bv13 32) main_~j~0)} #85#return; {21694#(= (_ bv13 32) main_~j~0)} is VALID [2018-11-23 11:34:50,477 INFO L256 TraceCheckUtils]: 323: Hoare triple {21694#(= (_ bv13 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,477 INFO L273 TraceCheckUtils]: 324: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,478 INFO L273 TraceCheckUtils]: 325: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,478 INFO L273 TraceCheckUtils]: 326: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,478 INFO L268 TraceCheckUtils]: 327: Hoare quadruple {20764#true} {21694#(= (_ bv13 32) main_~j~0)} #87#return; {21694#(= (_ bv13 32) main_~j~0)} is VALID [2018-11-23 11:34:50,479 INFO L256 TraceCheckUtils]: 328: Hoare triple {21694#(= (_ bv13 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,479 INFO L273 TraceCheckUtils]: 329: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,479 INFO L273 TraceCheckUtils]: 330: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,479 INFO L273 TraceCheckUtils]: 331: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,480 INFO L268 TraceCheckUtils]: 332: Hoare quadruple {20764#true} {21694#(= (_ bv13 32) main_~j~0)} #89#return; {21694#(= (_ bv13 32) main_~j~0)} is VALID [2018-11-23 11:34:50,480 INFO L256 TraceCheckUtils]: 333: Hoare triple {21694#(= (_ bv13 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,480 INFO L273 TraceCheckUtils]: 334: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,481 INFO L273 TraceCheckUtils]: 335: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,481 INFO L273 TraceCheckUtils]: 336: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,481 INFO L268 TraceCheckUtils]: 337: Hoare quadruple {20764#true} {21694#(= (_ bv13 32) main_~j~0)} #91#return; {21694#(= (_ bv13 32) main_~j~0)} is VALID [2018-11-23 11:34:50,482 INFO L273 TraceCheckUtils]: 338: Hoare triple {21694#(= (_ bv13 32) main_~j~0)} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {21797#(= (bvadd main_~j~0 (_ bv4294967282 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,482 INFO L256 TraceCheckUtils]: 339: Hoare triple {21797#(= (bvadd main_~j~0 (_ bv4294967282 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,482 INFO L273 TraceCheckUtils]: 340: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,482 INFO L273 TraceCheckUtils]: 341: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,482 INFO L273 TraceCheckUtils]: 342: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,483 INFO L268 TraceCheckUtils]: 343: Hoare quadruple {20764#true} {21797#(= (bvadd main_~j~0 (_ bv4294967282 32)) (_ bv0 32))} #93#return; {21797#(= (bvadd main_~j~0 (_ bv4294967282 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,483 INFO L256 TraceCheckUtils]: 344: Hoare triple {21797#(= (bvadd main_~j~0 (_ bv4294967282 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,483 INFO L273 TraceCheckUtils]: 345: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,483 INFO L273 TraceCheckUtils]: 346: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,483 INFO L273 TraceCheckUtils]: 347: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,484 INFO L268 TraceCheckUtils]: 348: Hoare quadruple {20764#true} {21797#(= (bvadd main_~j~0 (_ bv4294967282 32)) (_ bv0 32))} #95#return; {21797#(= (bvadd main_~j~0 (_ bv4294967282 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,484 INFO L256 TraceCheckUtils]: 349: Hoare triple {21797#(= (bvadd main_~j~0 (_ bv4294967282 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,484 INFO L273 TraceCheckUtils]: 350: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,484 INFO L273 TraceCheckUtils]: 351: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,484 INFO L273 TraceCheckUtils]: 352: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,485 INFO L268 TraceCheckUtils]: 353: Hoare quadruple {20764#true} {21797#(= (bvadd main_~j~0 (_ bv4294967282 32)) (_ bv0 32))} #97#return; {21797#(= (bvadd main_~j~0 (_ bv4294967282 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,485 INFO L256 TraceCheckUtils]: 354: Hoare triple {21797#(= (bvadd main_~j~0 (_ bv4294967282 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,485 INFO L273 TraceCheckUtils]: 355: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,485 INFO L273 TraceCheckUtils]: 356: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,485 INFO L273 TraceCheckUtils]: 357: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,486 INFO L268 TraceCheckUtils]: 358: Hoare quadruple {20764#true} {21797#(= (bvadd main_~j~0 (_ bv4294967282 32)) (_ bv0 32))} #99#return; {21797#(= (bvadd main_~j~0 (_ bv4294967282 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,488 INFO L273 TraceCheckUtils]: 359: Hoare triple {21797#(= (bvadd main_~j~0 (_ bv4294967282 32)) (_ bv0 32))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {21861#(= (_ bv15 32) main_~j~0)} is VALID [2018-11-23 11:34:50,488 INFO L256 TraceCheckUtils]: 360: Hoare triple {21861#(= (_ bv15 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,488 INFO L273 TraceCheckUtils]: 361: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,488 INFO L273 TraceCheckUtils]: 362: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,488 INFO L273 TraceCheckUtils]: 363: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,489 INFO L268 TraceCheckUtils]: 364: Hoare quadruple {20764#true} {21861#(= (_ bv15 32) main_~j~0)} #101#return; {21861#(= (_ bv15 32) main_~j~0)} is VALID [2018-11-23 11:34:50,489 INFO L256 TraceCheckUtils]: 365: Hoare triple {21861#(= (_ bv15 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,489 INFO L273 TraceCheckUtils]: 366: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,489 INFO L273 TraceCheckUtils]: 367: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,489 INFO L273 TraceCheckUtils]: 368: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,490 INFO L268 TraceCheckUtils]: 369: Hoare quadruple {20764#true} {21861#(= (_ bv15 32) main_~j~0)} #103#return; {21861#(= (_ bv15 32) main_~j~0)} is VALID [2018-11-23 11:34:50,490 INFO L273 TraceCheckUtils]: 370: Hoare triple {21861#(= (_ bv15 32) main_~j~0)} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,491 INFO L273 TraceCheckUtils]: 371: Hoare triple {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,491 INFO L273 TraceCheckUtils]: 372: Hoare triple {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,491 INFO L256 TraceCheckUtils]: 373: Hoare triple {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,491 INFO L273 TraceCheckUtils]: 374: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,491 INFO L273 TraceCheckUtils]: 375: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,492 INFO L273 TraceCheckUtils]: 376: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,492 INFO L268 TraceCheckUtils]: 377: Hoare quadruple {20764#true} {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} #81#return; {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,492 INFO L256 TraceCheckUtils]: 378: Hoare triple {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,492 INFO L273 TraceCheckUtils]: 379: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,492 INFO L273 TraceCheckUtils]: 380: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,492 INFO L273 TraceCheckUtils]: 381: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,493 INFO L268 TraceCheckUtils]: 382: Hoare quadruple {20764#true} {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} #83#return; {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,494 INFO L273 TraceCheckUtils]: 383: Hoare triple {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,494 INFO L256 TraceCheckUtils]: 384: Hoare triple {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,494 INFO L273 TraceCheckUtils]: 385: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,494 INFO L273 TraceCheckUtils]: 386: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,494 INFO L273 TraceCheckUtils]: 387: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,495 INFO L268 TraceCheckUtils]: 388: Hoare quadruple {20764#true} {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} #85#return; {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,495 INFO L256 TraceCheckUtils]: 389: Hoare triple {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,495 INFO L273 TraceCheckUtils]: 390: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,496 INFO L273 TraceCheckUtils]: 391: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,496 INFO L273 TraceCheckUtils]: 392: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,497 INFO L268 TraceCheckUtils]: 393: Hoare quadruple {20764#true} {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} #87#return; {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,497 INFO L256 TraceCheckUtils]: 394: Hoare triple {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,497 INFO L273 TraceCheckUtils]: 395: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,497 INFO L273 TraceCheckUtils]: 396: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,497 INFO L273 TraceCheckUtils]: 397: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,498 INFO L268 TraceCheckUtils]: 398: Hoare quadruple {20764#true} {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} #89#return; {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,498 INFO L256 TraceCheckUtils]: 399: Hoare triple {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,499 INFO L273 TraceCheckUtils]: 400: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,499 INFO L273 TraceCheckUtils]: 401: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,499 INFO L273 TraceCheckUtils]: 402: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,500 INFO L268 TraceCheckUtils]: 403: Hoare quadruple {20764#true} {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} #91#return; {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,500 INFO L273 TraceCheckUtils]: 404: Hoare triple {21895#(= (bvadd main_~j~0 (_ bv4294967280 32)) (_ bv0 32))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {21998#(= (_ bv17 32) main_~j~0)} is VALID [2018-11-23 11:34:50,500 INFO L256 TraceCheckUtils]: 405: Hoare triple {21998#(= (_ bv17 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,500 INFO L273 TraceCheckUtils]: 406: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,500 INFO L273 TraceCheckUtils]: 407: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,501 INFO L273 TraceCheckUtils]: 408: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,501 INFO L268 TraceCheckUtils]: 409: Hoare quadruple {20764#true} {21998#(= (_ bv17 32) main_~j~0)} #93#return; {21998#(= (_ bv17 32) main_~j~0)} is VALID [2018-11-23 11:34:50,501 INFO L256 TraceCheckUtils]: 410: Hoare triple {21998#(= (_ bv17 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,501 INFO L273 TraceCheckUtils]: 411: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,501 INFO L273 TraceCheckUtils]: 412: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,501 INFO L273 TraceCheckUtils]: 413: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,502 INFO L268 TraceCheckUtils]: 414: Hoare quadruple {20764#true} {21998#(= (_ bv17 32) main_~j~0)} #95#return; {21998#(= (_ bv17 32) main_~j~0)} is VALID [2018-11-23 11:34:50,502 INFO L256 TraceCheckUtils]: 415: Hoare triple {21998#(= (_ bv17 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,502 INFO L273 TraceCheckUtils]: 416: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,502 INFO L273 TraceCheckUtils]: 417: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,502 INFO L273 TraceCheckUtils]: 418: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,503 INFO L268 TraceCheckUtils]: 419: Hoare quadruple {20764#true} {21998#(= (_ bv17 32) main_~j~0)} #97#return; {21998#(= (_ bv17 32) main_~j~0)} is VALID [2018-11-23 11:34:50,503 INFO L256 TraceCheckUtils]: 420: Hoare triple {21998#(= (_ bv17 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,503 INFO L273 TraceCheckUtils]: 421: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,503 INFO L273 TraceCheckUtils]: 422: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,503 INFO L273 TraceCheckUtils]: 423: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,504 INFO L268 TraceCheckUtils]: 424: Hoare quadruple {20764#true} {21998#(= (_ bv17 32) main_~j~0)} #99#return; {21998#(= (_ bv17 32) main_~j~0)} is VALID [2018-11-23 11:34:50,505 INFO L273 TraceCheckUtils]: 425: Hoare triple {21998#(= (_ bv17 32) main_~j~0)} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {22062#(= (bvadd main_~j~0 (_ bv4294967278 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,505 INFO L256 TraceCheckUtils]: 426: Hoare triple {22062#(= (bvadd main_~j~0 (_ bv4294967278 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,505 INFO L273 TraceCheckUtils]: 427: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,505 INFO L273 TraceCheckUtils]: 428: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,505 INFO L273 TraceCheckUtils]: 429: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,506 INFO L268 TraceCheckUtils]: 430: Hoare quadruple {20764#true} {22062#(= (bvadd main_~j~0 (_ bv4294967278 32)) (_ bv0 32))} #101#return; {22062#(= (bvadd main_~j~0 (_ bv4294967278 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,506 INFO L256 TraceCheckUtils]: 431: Hoare triple {22062#(= (bvadd main_~j~0 (_ bv4294967278 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,507 INFO L273 TraceCheckUtils]: 432: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,507 INFO L273 TraceCheckUtils]: 433: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,507 INFO L273 TraceCheckUtils]: 434: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,507 INFO L268 TraceCheckUtils]: 435: Hoare quadruple {20764#true} {22062#(= (bvadd main_~j~0 (_ bv4294967278 32)) (_ bv0 32))} #103#return; {22062#(= (bvadd main_~j~0 (_ bv4294967278 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,508 INFO L273 TraceCheckUtils]: 436: Hoare triple {22062#(= (bvadd main_~j~0 (_ bv4294967278 32)) (_ bv0 32))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {22096#(= (_ bv19 32) main_~j~0)} is VALID [2018-11-23 11:34:50,508 INFO L273 TraceCheckUtils]: 437: Hoare triple {22096#(= (_ bv19 32) main_~j~0)} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {22096#(= (_ bv19 32) main_~j~0)} is VALID [2018-11-23 11:34:50,508 INFO L273 TraceCheckUtils]: 438: Hoare triple {22096#(= (_ bv19 32) main_~j~0)} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {22096#(= (_ bv19 32) main_~j~0)} is VALID [2018-11-23 11:34:50,509 INFO L256 TraceCheckUtils]: 439: Hoare triple {22096#(= (_ bv19 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,509 INFO L273 TraceCheckUtils]: 440: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,509 INFO L273 TraceCheckUtils]: 441: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,509 INFO L273 TraceCheckUtils]: 442: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,509 INFO L268 TraceCheckUtils]: 443: Hoare quadruple {20764#true} {22096#(= (_ bv19 32) main_~j~0)} #81#return; {22096#(= (_ bv19 32) main_~j~0)} is VALID [2018-11-23 11:34:50,509 INFO L256 TraceCheckUtils]: 444: Hoare triple {22096#(= (_ bv19 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,510 INFO L273 TraceCheckUtils]: 445: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,510 INFO L273 TraceCheckUtils]: 446: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,510 INFO L273 TraceCheckUtils]: 447: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,510 INFO L268 TraceCheckUtils]: 448: Hoare quadruple {20764#true} {22096#(= (_ bv19 32) main_~j~0)} #83#return; {22096#(= (_ bv19 32) main_~j~0)} is VALID [2018-11-23 11:34:50,511 INFO L273 TraceCheckUtils]: 449: Hoare triple {22096#(= (_ bv19 32) main_~j~0)} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {22096#(= (_ bv19 32) main_~j~0)} is VALID [2018-11-23 11:34:50,511 INFO L256 TraceCheckUtils]: 450: Hoare triple {22096#(= (_ bv19 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,511 INFO L273 TraceCheckUtils]: 451: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,511 INFO L273 TraceCheckUtils]: 452: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,511 INFO L273 TraceCheckUtils]: 453: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,511 INFO L268 TraceCheckUtils]: 454: Hoare quadruple {20764#true} {22096#(= (_ bv19 32) main_~j~0)} #85#return; {22096#(= (_ bv19 32) main_~j~0)} is VALID [2018-11-23 11:34:50,512 INFO L256 TraceCheckUtils]: 455: Hoare triple {22096#(= (_ bv19 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,512 INFO L273 TraceCheckUtils]: 456: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,512 INFO L273 TraceCheckUtils]: 457: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,512 INFO L273 TraceCheckUtils]: 458: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,512 INFO L268 TraceCheckUtils]: 459: Hoare quadruple {20764#true} {22096#(= (_ bv19 32) main_~j~0)} #87#return; {22096#(= (_ bv19 32) main_~j~0)} is VALID [2018-11-23 11:34:50,512 INFO L256 TraceCheckUtils]: 460: Hoare triple {22096#(= (_ bv19 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,513 INFO L273 TraceCheckUtils]: 461: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,513 INFO L273 TraceCheckUtils]: 462: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,513 INFO L273 TraceCheckUtils]: 463: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,514 INFO L268 TraceCheckUtils]: 464: Hoare quadruple {20764#true} {22096#(= (_ bv19 32) main_~j~0)} #89#return; {22096#(= (_ bv19 32) main_~j~0)} is VALID [2018-11-23 11:34:50,514 INFO L256 TraceCheckUtils]: 465: Hoare triple {22096#(= (_ bv19 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,514 INFO L273 TraceCheckUtils]: 466: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,514 INFO L273 TraceCheckUtils]: 467: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,514 INFO L273 TraceCheckUtils]: 468: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,515 INFO L268 TraceCheckUtils]: 469: Hoare quadruple {20764#true} {22096#(= (_ bv19 32) main_~j~0)} #91#return; {22096#(= (_ bv19 32) main_~j~0)} is VALID [2018-11-23 11:34:50,516 INFO L273 TraceCheckUtils]: 470: Hoare triple {22096#(= (_ bv19 32) main_~j~0)} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {22199#(= (bvadd main_~j~0 (_ bv4294967276 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,516 INFO L256 TraceCheckUtils]: 471: Hoare triple {22199#(= (bvadd main_~j~0 (_ bv4294967276 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,517 INFO L273 TraceCheckUtils]: 472: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,517 INFO L273 TraceCheckUtils]: 473: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,517 INFO L273 TraceCheckUtils]: 474: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,520 INFO L268 TraceCheckUtils]: 475: Hoare quadruple {20764#true} {22199#(= (bvadd main_~j~0 (_ bv4294967276 32)) (_ bv0 32))} #93#return; {22199#(= (bvadd main_~j~0 (_ bv4294967276 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,520 INFO L256 TraceCheckUtils]: 476: Hoare triple {22199#(= (bvadd main_~j~0 (_ bv4294967276 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,520 INFO L273 TraceCheckUtils]: 477: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,520 INFO L273 TraceCheckUtils]: 478: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,520 INFO L273 TraceCheckUtils]: 479: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,521 INFO L268 TraceCheckUtils]: 480: Hoare quadruple {20764#true} {22199#(= (bvadd main_~j~0 (_ bv4294967276 32)) (_ bv0 32))} #95#return; {22199#(= (bvadd main_~j~0 (_ bv4294967276 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,521 INFO L256 TraceCheckUtils]: 481: Hoare triple {22199#(= (bvadd main_~j~0 (_ bv4294967276 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,521 INFO L273 TraceCheckUtils]: 482: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,521 INFO L273 TraceCheckUtils]: 483: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,522 INFO L273 TraceCheckUtils]: 484: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,522 INFO L268 TraceCheckUtils]: 485: Hoare quadruple {20764#true} {22199#(= (bvadd main_~j~0 (_ bv4294967276 32)) (_ bv0 32))} #97#return; {22199#(= (bvadd main_~j~0 (_ bv4294967276 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,523 INFO L256 TraceCheckUtils]: 486: Hoare triple {22199#(= (bvadd main_~j~0 (_ bv4294967276 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,523 INFO L273 TraceCheckUtils]: 487: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,523 INFO L273 TraceCheckUtils]: 488: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,523 INFO L273 TraceCheckUtils]: 489: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,523 INFO L268 TraceCheckUtils]: 490: Hoare quadruple {20764#true} {22199#(= (bvadd main_~j~0 (_ bv4294967276 32)) (_ bv0 32))} #99#return; {22199#(= (bvadd main_~j~0 (_ bv4294967276 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,524 INFO L273 TraceCheckUtils]: 491: Hoare triple {22199#(= (bvadd main_~j~0 (_ bv4294967276 32)) (_ bv0 32))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {22263#(= (_ bv21 32) main_~j~0)} is VALID [2018-11-23 11:34:50,524 INFO L256 TraceCheckUtils]: 492: Hoare triple {22263#(= (_ bv21 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,525 INFO L273 TraceCheckUtils]: 493: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,525 INFO L273 TraceCheckUtils]: 494: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,525 INFO L273 TraceCheckUtils]: 495: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,525 INFO L268 TraceCheckUtils]: 496: Hoare quadruple {20764#true} {22263#(= (_ bv21 32) main_~j~0)} #101#return; {22263#(= (_ bv21 32) main_~j~0)} is VALID [2018-11-23 11:34:50,525 INFO L256 TraceCheckUtils]: 497: Hoare triple {22263#(= (_ bv21 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,526 INFO L273 TraceCheckUtils]: 498: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,526 INFO L273 TraceCheckUtils]: 499: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,526 INFO L273 TraceCheckUtils]: 500: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,526 INFO L268 TraceCheckUtils]: 501: Hoare quadruple {20764#true} {22263#(= (_ bv21 32) main_~j~0)} #103#return; {22263#(= (_ bv21 32) main_~j~0)} is VALID [2018-11-23 11:34:50,527 INFO L273 TraceCheckUtils]: 502: Hoare triple {22263#(= (_ bv21 32) main_~j~0)} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,527 INFO L273 TraceCheckUtils]: 503: Hoare triple {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,527 INFO L273 TraceCheckUtils]: 504: Hoare triple {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,527 INFO L256 TraceCheckUtils]: 505: Hoare triple {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,527 INFO L273 TraceCheckUtils]: 506: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,527 INFO L273 TraceCheckUtils]: 507: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,528 INFO L273 TraceCheckUtils]: 508: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,528 INFO L268 TraceCheckUtils]: 509: Hoare quadruple {20764#true} {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} #105#return; {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,528 INFO L256 TraceCheckUtils]: 510: Hoare triple {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,528 INFO L273 TraceCheckUtils]: 511: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,528 INFO L273 TraceCheckUtils]: 512: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,529 INFO L273 TraceCheckUtils]: 513: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,529 INFO L268 TraceCheckUtils]: 514: Hoare quadruple {20764#true} {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} #107#return; {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,529 INFO L256 TraceCheckUtils]: 515: Hoare triple {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:50,529 INFO L273 TraceCheckUtils]: 516: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:50,529 INFO L273 TraceCheckUtils]: 517: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:50,529 INFO L273 TraceCheckUtils]: 518: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:50,530 INFO L268 TraceCheckUtils]: 519: Hoare quadruple {20764#true} {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} #109#return; {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,530 INFO L256 TraceCheckUtils]: 520: Hoare triple {22297#(= (bvadd main_~j~0 (_ bv4294967274 32)) (_ bv0 32))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {22352#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,531 INFO L273 TraceCheckUtils]: 521: Hoare triple {22352#(= (bvadd |__VERIFIER_assert_#in~cond| (_ bv4294967295 32)) (_ bv0 32))} ~cond := #in~cond; {22356#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} is VALID [2018-11-23 11:34:50,532 INFO L273 TraceCheckUtils]: 522: Hoare triple {22356#(= (bvadd __VERIFIER_assert_~cond (_ bv4294967295 32)) (_ bv0 32))} assume 0bv32 == ~cond; {20765#false} is VALID [2018-11-23 11:34:50,532 INFO L273 TraceCheckUtils]: 523: Hoare triple {20765#false} assume !false; {20765#false} is VALID [2018-11-23 11:34:50,675 INFO L134 CoverageAnalysis]: Checked inductivity of 17731 backedges. 186 proven. 433 refuted. 0 times theorem prover too weak. 17112 trivial. 0 not checked. [2018-11-23 11:34:50,675 INFO L316 TraceCheckSpWp]: Computing backward predicates... [2018-11-23 11:34:53,473 INFO L273 TraceCheckUtils]: 523: Hoare triple {20765#false} assume !false; {20765#false} is VALID [2018-11-23 11:34:53,473 INFO L273 TraceCheckUtils]: 522: Hoare triple {22366#(not (= (_ bv0 32) __VERIFIER_assert_~cond))} assume 0bv32 == ~cond; {20765#false} is VALID [2018-11-23 11:34:53,474 INFO L273 TraceCheckUtils]: 521: Hoare triple {22370#(not (= |__VERIFIER_assert_#in~cond| (_ bv0 32)))} ~cond := #in~cond; {22366#(not (= (_ bv0 32) __VERIFIER_assert_~cond))} is VALID [2018-11-23 11:34:53,475 INFO L256 TraceCheckUtils]: 520: Hoare triple {22374#(bvsle (_ bv0 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {22370#(not (= |__VERIFIER_assert_#in~cond| (_ bv0 32)))} is VALID [2018-11-23 11:34:53,476 INFO L268 TraceCheckUtils]: 519: Hoare quadruple {20764#true} {22374#(bvsle (_ bv0 32) main_~j~0)} #109#return; {22374#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:34:53,476 INFO L273 TraceCheckUtils]: 518: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,476 INFO L273 TraceCheckUtils]: 517: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,476 INFO L273 TraceCheckUtils]: 516: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,477 INFO L256 TraceCheckUtils]: 515: Hoare triple {22374#(bvsle (_ bv0 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,477 INFO L268 TraceCheckUtils]: 514: Hoare quadruple {20764#true} {22374#(bvsle (_ bv0 32) main_~j~0)} #107#return; {22374#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:34:53,477 INFO L273 TraceCheckUtils]: 513: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,478 INFO L273 TraceCheckUtils]: 512: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,478 INFO L273 TraceCheckUtils]: 511: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,478 INFO L256 TraceCheckUtils]: 510: Hoare triple {22374#(bvsle (_ bv0 32) main_~j~0)} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,479 INFO L268 TraceCheckUtils]: 509: Hoare quadruple {20764#true} {22374#(bvsle (_ bv0 32) main_~j~0)} #105#return; {22374#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:34:53,479 INFO L273 TraceCheckUtils]: 508: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,479 INFO L273 TraceCheckUtils]: 507: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,479 INFO L273 TraceCheckUtils]: 506: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,479 INFO L256 TraceCheckUtils]: 505: Hoare triple {22374#(bvsle (_ bv0 32) main_~j~0)} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,479 INFO L273 TraceCheckUtils]: 504: Hoare triple {22374#(bvsle (_ bv0 32) main_~j~0)} assume !~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {22374#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:34:53,480 INFO L273 TraceCheckUtils]: 503: Hoare triple {22374#(bvsle (_ bv0 32) main_~j~0)} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {22374#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:34:53,480 INFO L273 TraceCheckUtils]: 502: Hoare triple {22429#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {22374#(bvsle (_ bv0 32) main_~j~0)} is VALID [2018-11-23 11:34:53,481 INFO L268 TraceCheckUtils]: 501: Hoare quadruple {20764#true} {22429#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} #103#return; {22429#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:34:53,481 INFO L273 TraceCheckUtils]: 500: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,481 INFO L273 TraceCheckUtils]: 499: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,481 INFO L273 TraceCheckUtils]: 498: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,482 INFO L256 TraceCheckUtils]: 497: Hoare triple {22429#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,482 INFO L268 TraceCheckUtils]: 496: Hoare quadruple {20764#true} {22429#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} #101#return; {22429#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:34:53,482 INFO L273 TraceCheckUtils]: 495: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,483 INFO L273 TraceCheckUtils]: 494: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,483 INFO L273 TraceCheckUtils]: 493: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,483 INFO L256 TraceCheckUtils]: 492: Hoare triple {22429#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,485 INFO L273 TraceCheckUtils]: 491: Hoare triple {22463#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {22429#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv1 32)))} is VALID [2018-11-23 11:34:53,486 INFO L268 TraceCheckUtils]: 490: Hoare quadruple {20764#true} {22463#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} #99#return; {22463#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} is VALID [2018-11-23 11:34:53,486 INFO L273 TraceCheckUtils]: 489: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,486 INFO L273 TraceCheckUtils]: 488: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,486 INFO L273 TraceCheckUtils]: 487: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,487 INFO L256 TraceCheckUtils]: 486: Hoare triple {22463#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,487 INFO L268 TraceCheckUtils]: 485: Hoare quadruple {20764#true} {22463#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} #97#return; {22463#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} is VALID [2018-11-23 11:34:53,488 INFO L273 TraceCheckUtils]: 484: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,488 INFO L273 TraceCheckUtils]: 483: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,488 INFO L273 TraceCheckUtils]: 482: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,488 INFO L256 TraceCheckUtils]: 481: Hoare triple {22463#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,489 INFO L268 TraceCheckUtils]: 480: Hoare quadruple {20764#true} {22463#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} #95#return; {22463#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} is VALID [2018-11-23 11:34:53,489 INFO L273 TraceCheckUtils]: 479: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,489 INFO L273 TraceCheckUtils]: 478: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,489 INFO L273 TraceCheckUtils]: 477: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,490 INFO L256 TraceCheckUtils]: 476: Hoare triple {22463#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,490 INFO L268 TraceCheckUtils]: 475: Hoare quadruple {20764#true} {22463#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} #93#return; {22463#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} is VALID [2018-11-23 11:34:53,490 INFO L273 TraceCheckUtils]: 474: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,490 INFO L273 TraceCheckUtils]: 473: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,490 INFO L273 TraceCheckUtils]: 472: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,490 INFO L256 TraceCheckUtils]: 471: Hoare triple {22463#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,494 INFO L273 TraceCheckUtils]: 470: Hoare triple {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {22463#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv2 32)))} is VALID [2018-11-23 11:34:53,495 INFO L268 TraceCheckUtils]: 469: Hoare quadruple {20764#true} {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #91#return; {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:34:53,495 INFO L273 TraceCheckUtils]: 468: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,495 INFO L273 TraceCheckUtils]: 467: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,495 INFO L273 TraceCheckUtils]: 466: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,495 INFO L256 TraceCheckUtils]: 465: Hoare triple {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,496 INFO L268 TraceCheckUtils]: 464: Hoare quadruple {20764#true} {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #89#return; {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:34:53,496 INFO L273 TraceCheckUtils]: 463: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,496 INFO L273 TraceCheckUtils]: 462: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,496 INFO L273 TraceCheckUtils]: 461: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,496 INFO L256 TraceCheckUtils]: 460: Hoare triple {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,497 INFO L268 TraceCheckUtils]: 459: Hoare quadruple {20764#true} {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #87#return; {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:34:53,497 INFO L273 TraceCheckUtils]: 458: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,497 INFO L273 TraceCheckUtils]: 457: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,497 INFO L273 TraceCheckUtils]: 456: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,497 INFO L256 TraceCheckUtils]: 455: Hoare triple {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,498 INFO L268 TraceCheckUtils]: 454: Hoare quadruple {20764#true} {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #85#return; {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:34:53,498 INFO L273 TraceCheckUtils]: 453: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,498 INFO L273 TraceCheckUtils]: 452: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,498 INFO L273 TraceCheckUtils]: 451: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,499 INFO L256 TraceCheckUtils]: 450: Hoare triple {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,499 INFO L273 TraceCheckUtils]: 449: Hoare triple {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:34:53,499 INFO L268 TraceCheckUtils]: 448: Hoare quadruple {20764#true} {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #83#return; {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:34:53,499 INFO L273 TraceCheckUtils]: 447: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,500 INFO L273 TraceCheckUtils]: 446: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,500 INFO L273 TraceCheckUtils]: 445: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,500 INFO L256 TraceCheckUtils]: 444: Hoare triple {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,500 INFO L268 TraceCheckUtils]: 443: Hoare quadruple {20764#true} {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} #81#return; {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:34:53,500 INFO L273 TraceCheckUtils]: 442: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,500 INFO L273 TraceCheckUtils]: 441: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,501 INFO L273 TraceCheckUtils]: 440: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,501 INFO L256 TraceCheckUtils]: 439: Hoare triple {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,501 INFO L273 TraceCheckUtils]: 438: Hoare triple {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:34:53,501 INFO L273 TraceCheckUtils]: 437: Hoare triple {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:34:53,505 INFO L273 TraceCheckUtils]: 436: Hoare triple {22630#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {22527#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv3 32)))} is VALID [2018-11-23 11:34:53,506 INFO L268 TraceCheckUtils]: 435: Hoare quadruple {20764#true} {22630#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} #103#return; {22630#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:34:53,506 INFO L273 TraceCheckUtils]: 434: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,506 INFO L273 TraceCheckUtils]: 433: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,506 INFO L273 TraceCheckUtils]: 432: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,506 INFO L256 TraceCheckUtils]: 431: Hoare triple {22630#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,507 INFO L268 TraceCheckUtils]: 430: Hoare quadruple {20764#true} {22630#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} #101#return; {22630#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:34:53,507 INFO L273 TraceCheckUtils]: 429: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,507 INFO L273 TraceCheckUtils]: 428: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,508 INFO L273 TraceCheckUtils]: 427: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,508 INFO L256 TraceCheckUtils]: 426: Hoare triple {22630#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,510 INFO L273 TraceCheckUtils]: 425: Hoare triple {22664#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {22630#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv4 32)))} is VALID [2018-11-23 11:34:53,511 INFO L268 TraceCheckUtils]: 424: Hoare quadruple {20764#true} {22664#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} #99#return; {22664#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} is VALID [2018-11-23 11:34:53,511 INFO L273 TraceCheckUtils]: 423: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,511 INFO L273 TraceCheckUtils]: 422: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,512 INFO L273 TraceCheckUtils]: 421: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,512 INFO L256 TraceCheckUtils]: 420: Hoare triple {22664#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,512 INFO L268 TraceCheckUtils]: 419: Hoare quadruple {20764#true} {22664#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} #97#return; {22664#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} is VALID [2018-11-23 11:34:53,513 INFO L273 TraceCheckUtils]: 418: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,513 INFO L273 TraceCheckUtils]: 417: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,513 INFO L273 TraceCheckUtils]: 416: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,513 INFO L256 TraceCheckUtils]: 415: Hoare triple {22664#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,514 INFO L268 TraceCheckUtils]: 414: Hoare quadruple {20764#true} {22664#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} #95#return; {22664#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} is VALID [2018-11-23 11:34:53,514 INFO L273 TraceCheckUtils]: 413: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,514 INFO L273 TraceCheckUtils]: 412: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,515 INFO L273 TraceCheckUtils]: 411: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,515 INFO L256 TraceCheckUtils]: 410: Hoare triple {22664#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,515 INFO L268 TraceCheckUtils]: 409: Hoare quadruple {20764#true} {22664#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} #93#return; {22664#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} is VALID [2018-11-23 11:34:53,516 INFO L273 TraceCheckUtils]: 408: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,516 INFO L273 TraceCheckUtils]: 407: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,516 INFO L273 TraceCheckUtils]: 406: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,516 INFO L256 TraceCheckUtils]: 405: Hoare triple {22664#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,519 INFO L273 TraceCheckUtils]: 404: Hoare triple {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {22664#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv5 32)))} is VALID [2018-11-23 11:34:53,520 INFO L268 TraceCheckUtils]: 403: Hoare quadruple {20764#true} {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} #91#return; {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:34:53,520 INFO L273 TraceCheckUtils]: 402: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,520 INFO L273 TraceCheckUtils]: 401: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,520 INFO L273 TraceCheckUtils]: 400: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,521 INFO L256 TraceCheckUtils]: 399: Hoare triple {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,521 INFO L268 TraceCheckUtils]: 398: Hoare quadruple {20764#true} {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} #89#return; {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:34:53,521 INFO L273 TraceCheckUtils]: 397: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,521 INFO L273 TraceCheckUtils]: 396: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,521 INFO L273 TraceCheckUtils]: 395: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,521 INFO L256 TraceCheckUtils]: 394: Hoare triple {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,522 INFO L268 TraceCheckUtils]: 393: Hoare quadruple {20764#true} {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} #87#return; {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:34:53,522 INFO L273 TraceCheckUtils]: 392: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,522 INFO L273 TraceCheckUtils]: 391: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,522 INFO L273 TraceCheckUtils]: 390: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,522 INFO L256 TraceCheckUtils]: 389: Hoare triple {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,523 INFO L268 TraceCheckUtils]: 388: Hoare quadruple {20764#true} {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} #85#return; {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:34:53,523 INFO L273 TraceCheckUtils]: 387: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,524 INFO L273 TraceCheckUtils]: 386: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,524 INFO L273 TraceCheckUtils]: 385: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,524 INFO L256 TraceCheckUtils]: 384: Hoare triple {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,524 INFO L273 TraceCheckUtils]: 383: Hoare triple {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:34:53,524 INFO L268 TraceCheckUtils]: 382: Hoare quadruple {20764#true} {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} #83#return; {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:34:53,525 INFO L273 TraceCheckUtils]: 381: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,525 INFO L273 TraceCheckUtils]: 380: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,525 INFO L273 TraceCheckUtils]: 379: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,525 INFO L256 TraceCheckUtils]: 378: Hoare triple {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,525 INFO L268 TraceCheckUtils]: 377: Hoare quadruple {20764#true} {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} #81#return; {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:34:53,526 INFO L273 TraceCheckUtils]: 376: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,526 INFO L273 TraceCheckUtils]: 375: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,526 INFO L273 TraceCheckUtils]: 374: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,526 INFO L256 TraceCheckUtils]: 373: Hoare triple {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,526 INFO L273 TraceCheckUtils]: 372: Hoare triple {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:34:53,527 INFO L273 TraceCheckUtils]: 371: Hoare triple {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:34:53,530 INFO L273 TraceCheckUtils]: 370: Hoare triple {22831#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {22728#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv6 32)))} is VALID [2018-11-23 11:34:53,531 INFO L268 TraceCheckUtils]: 369: Hoare quadruple {20764#true} {22831#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} #103#return; {22831#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} is VALID [2018-11-23 11:34:53,531 INFO L273 TraceCheckUtils]: 368: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,531 INFO L273 TraceCheckUtils]: 367: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,532 INFO L273 TraceCheckUtils]: 366: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,532 INFO L256 TraceCheckUtils]: 365: Hoare triple {22831#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,532 INFO L268 TraceCheckUtils]: 364: Hoare quadruple {20764#true} {22831#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} #101#return; {22831#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} is VALID [2018-11-23 11:34:53,532 INFO L273 TraceCheckUtils]: 363: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,532 INFO L273 TraceCheckUtils]: 362: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,533 INFO L273 TraceCheckUtils]: 361: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,533 INFO L256 TraceCheckUtils]: 360: Hoare triple {22831#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,536 INFO L273 TraceCheckUtils]: 359: Hoare triple {22865#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {22831#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv7 32)))} is VALID [2018-11-23 11:34:53,536 INFO L268 TraceCheckUtils]: 358: Hoare quadruple {20764#true} {22865#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} #99#return; {22865#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} is VALID [2018-11-23 11:34:53,537 INFO L273 TraceCheckUtils]: 357: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,537 INFO L273 TraceCheckUtils]: 356: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,537 INFO L273 TraceCheckUtils]: 355: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,537 INFO L256 TraceCheckUtils]: 354: Hoare triple {22865#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,538 INFO L268 TraceCheckUtils]: 353: Hoare quadruple {20764#true} {22865#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} #97#return; {22865#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} is VALID [2018-11-23 11:34:53,538 INFO L273 TraceCheckUtils]: 352: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,538 INFO L273 TraceCheckUtils]: 351: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,538 INFO L273 TraceCheckUtils]: 350: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,538 INFO L256 TraceCheckUtils]: 349: Hoare triple {22865#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,539 INFO L268 TraceCheckUtils]: 348: Hoare quadruple {20764#true} {22865#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} #95#return; {22865#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} is VALID [2018-11-23 11:34:53,539 INFO L273 TraceCheckUtils]: 347: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,539 INFO L273 TraceCheckUtils]: 346: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,539 INFO L273 TraceCheckUtils]: 345: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,539 INFO L256 TraceCheckUtils]: 344: Hoare triple {22865#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,540 INFO L268 TraceCheckUtils]: 343: Hoare quadruple {20764#true} {22865#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} #93#return; {22865#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} is VALID [2018-11-23 11:34:53,540 INFO L273 TraceCheckUtils]: 342: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,540 INFO L273 TraceCheckUtils]: 341: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,540 INFO L273 TraceCheckUtils]: 340: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,541 INFO L256 TraceCheckUtils]: 339: Hoare triple {22865#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,543 INFO L273 TraceCheckUtils]: 338: Hoare triple {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {22865#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv8 32)))} is VALID [2018-11-23 11:34:53,544 INFO L268 TraceCheckUtils]: 337: Hoare quadruple {20764#true} {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} #91#return; {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:34:53,544 INFO L273 TraceCheckUtils]: 336: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,545 INFO L273 TraceCheckUtils]: 335: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,545 INFO L273 TraceCheckUtils]: 334: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,545 INFO L256 TraceCheckUtils]: 333: Hoare triple {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,546 INFO L268 TraceCheckUtils]: 332: Hoare quadruple {20764#true} {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} #89#return; {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:34:53,546 INFO L273 TraceCheckUtils]: 331: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,546 INFO L273 TraceCheckUtils]: 330: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,546 INFO L273 TraceCheckUtils]: 329: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,546 INFO L256 TraceCheckUtils]: 328: Hoare triple {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,547 INFO L268 TraceCheckUtils]: 327: Hoare quadruple {20764#true} {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} #87#return; {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:34:53,547 INFO L273 TraceCheckUtils]: 326: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,548 INFO L273 TraceCheckUtils]: 325: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,548 INFO L273 TraceCheckUtils]: 324: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,548 INFO L256 TraceCheckUtils]: 323: Hoare triple {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,548 INFO L268 TraceCheckUtils]: 322: Hoare quadruple {20764#true} {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} #85#return; {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:34:53,548 INFO L273 TraceCheckUtils]: 321: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,548 INFO L273 TraceCheckUtils]: 320: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,549 INFO L273 TraceCheckUtils]: 319: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,549 INFO L256 TraceCheckUtils]: 318: Hoare triple {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,549 INFO L273 TraceCheckUtils]: 317: Hoare triple {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:34:53,549 INFO L268 TraceCheckUtils]: 316: Hoare quadruple {20764#true} {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} #83#return; {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:34:53,550 INFO L273 TraceCheckUtils]: 315: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,550 INFO L273 TraceCheckUtils]: 314: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,550 INFO L273 TraceCheckUtils]: 313: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,550 INFO L256 TraceCheckUtils]: 312: Hoare triple {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,550 INFO L268 TraceCheckUtils]: 311: Hoare quadruple {20764#true} {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} #81#return; {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:34:53,550 INFO L273 TraceCheckUtils]: 310: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,551 INFO L273 TraceCheckUtils]: 309: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,551 INFO L273 TraceCheckUtils]: 308: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,551 INFO L256 TraceCheckUtils]: 307: Hoare triple {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,551 INFO L273 TraceCheckUtils]: 306: Hoare triple {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:34:53,551 INFO L273 TraceCheckUtils]: 305: Hoare triple {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:34:53,556 INFO L273 TraceCheckUtils]: 304: Hoare triple {23032#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {22929#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv9 32)))} is VALID [2018-11-23 11:34:53,556 INFO L268 TraceCheckUtils]: 303: Hoare quadruple {20764#true} {23032#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} #103#return; {23032#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} is VALID [2018-11-23 11:34:53,556 INFO L273 TraceCheckUtils]: 302: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,556 INFO L273 TraceCheckUtils]: 301: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,557 INFO L273 TraceCheckUtils]: 300: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,557 INFO L256 TraceCheckUtils]: 299: Hoare triple {23032#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,557 INFO L268 TraceCheckUtils]: 298: Hoare quadruple {20764#true} {23032#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} #101#return; {23032#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} is VALID [2018-11-23 11:34:53,557 INFO L273 TraceCheckUtils]: 297: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,557 INFO L273 TraceCheckUtils]: 296: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,557 INFO L273 TraceCheckUtils]: 295: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,558 INFO L256 TraceCheckUtils]: 294: Hoare triple {23032#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,560 INFO L273 TraceCheckUtils]: 293: Hoare triple {23066#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv11 32)))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {23032#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv10 32)))} is VALID [2018-11-23 11:34:53,561 INFO L268 TraceCheckUtils]: 292: Hoare quadruple {20764#true} {23066#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv11 32)))} #99#return; {23066#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv11 32)))} is VALID [2018-11-23 11:34:53,561 INFO L273 TraceCheckUtils]: 291: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,562 INFO L273 TraceCheckUtils]: 290: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,562 INFO L273 TraceCheckUtils]: 289: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,562 INFO L256 TraceCheckUtils]: 288: Hoare triple {23066#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv11 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,562 INFO L268 TraceCheckUtils]: 287: Hoare quadruple {20764#true} {23066#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv11 32)))} #97#return; {23066#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv11 32)))} is VALID [2018-11-23 11:34:53,562 INFO L273 TraceCheckUtils]: 286: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,562 INFO L273 TraceCheckUtils]: 285: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,563 INFO L273 TraceCheckUtils]: 284: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,563 INFO L256 TraceCheckUtils]: 283: Hoare triple {23066#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv11 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,563 INFO L268 TraceCheckUtils]: 282: Hoare quadruple {20764#true} {23066#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv11 32)))} #95#return; {23066#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv11 32)))} is VALID [2018-11-23 11:34:53,563 INFO L273 TraceCheckUtils]: 281: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,563 INFO L273 TraceCheckUtils]: 280: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,563 INFO L273 TraceCheckUtils]: 279: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,564 INFO L256 TraceCheckUtils]: 278: Hoare triple {23066#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv11 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,564 INFO L268 TraceCheckUtils]: 277: Hoare quadruple {20764#true} {23066#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv11 32)))} #93#return; {23066#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv11 32)))} is VALID [2018-11-23 11:34:53,564 INFO L273 TraceCheckUtils]: 276: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,564 INFO L273 TraceCheckUtils]: 275: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,564 INFO L273 TraceCheckUtils]: 274: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,565 INFO L256 TraceCheckUtils]: 273: Hoare triple {23066#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv11 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,569 INFO L273 TraceCheckUtils]: 272: Hoare triple {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {23066#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv11 32)))} is VALID [2018-11-23 11:34:53,570 INFO L268 TraceCheckUtils]: 271: Hoare quadruple {20764#true} {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} #91#return; {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} is VALID [2018-11-23 11:34:53,570 INFO L273 TraceCheckUtils]: 270: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,570 INFO L273 TraceCheckUtils]: 269: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,570 INFO L273 TraceCheckUtils]: 268: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,571 INFO L256 TraceCheckUtils]: 267: Hoare triple {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,571 INFO L268 TraceCheckUtils]: 266: Hoare quadruple {20764#true} {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} #89#return; {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} is VALID [2018-11-23 11:34:53,571 INFO L273 TraceCheckUtils]: 265: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,571 INFO L273 TraceCheckUtils]: 264: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,571 INFO L273 TraceCheckUtils]: 263: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,571 INFO L256 TraceCheckUtils]: 262: Hoare triple {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,572 INFO L268 TraceCheckUtils]: 261: Hoare quadruple {20764#true} {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} #87#return; {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} is VALID [2018-11-23 11:34:53,572 INFO L273 TraceCheckUtils]: 260: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,573 INFO L273 TraceCheckUtils]: 259: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,573 INFO L273 TraceCheckUtils]: 258: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,573 INFO L256 TraceCheckUtils]: 257: Hoare triple {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,574 INFO L268 TraceCheckUtils]: 256: Hoare quadruple {20764#true} {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} #85#return; {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} is VALID [2018-11-23 11:34:53,574 INFO L273 TraceCheckUtils]: 255: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,574 INFO L273 TraceCheckUtils]: 254: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,574 INFO L273 TraceCheckUtils]: 253: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,574 INFO L256 TraceCheckUtils]: 252: Hoare triple {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,575 INFO L273 TraceCheckUtils]: 251: Hoare triple {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} is VALID [2018-11-23 11:34:53,576 INFO L268 TraceCheckUtils]: 250: Hoare quadruple {20764#true} {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} #83#return; {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} is VALID [2018-11-23 11:34:53,576 INFO L273 TraceCheckUtils]: 249: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,576 INFO L273 TraceCheckUtils]: 248: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,576 INFO L273 TraceCheckUtils]: 247: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,576 INFO L256 TraceCheckUtils]: 246: Hoare triple {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,577 INFO L268 TraceCheckUtils]: 245: Hoare quadruple {20764#true} {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} #81#return; {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} is VALID [2018-11-23 11:34:53,577 INFO L273 TraceCheckUtils]: 244: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,578 INFO L273 TraceCheckUtils]: 243: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,578 INFO L273 TraceCheckUtils]: 242: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,578 INFO L256 TraceCheckUtils]: 241: Hoare triple {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,578 INFO L273 TraceCheckUtils]: 240: Hoare triple {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} is VALID [2018-11-23 11:34:53,579 INFO L273 TraceCheckUtils]: 239: Hoare triple {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} is VALID [2018-11-23 11:34:53,581 INFO L273 TraceCheckUtils]: 238: Hoare triple {23233#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv13 32)))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {23130#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv12 32)))} is VALID [2018-11-23 11:34:53,582 INFO L268 TraceCheckUtils]: 237: Hoare quadruple {20764#true} {23233#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv13 32)))} #103#return; {23233#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv13 32)))} is VALID [2018-11-23 11:34:53,582 INFO L273 TraceCheckUtils]: 236: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,582 INFO L273 TraceCheckUtils]: 235: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,582 INFO L273 TraceCheckUtils]: 234: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,582 INFO L256 TraceCheckUtils]: 233: Hoare triple {23233#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv13 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,583 INFO L268 TraceCheckUtils]: 232: Hoare quadruple {20764#true} {23233#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv13 32)))} #101#return; {23233#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv13 32)))} is VALID [2018-11-23 11:34:53,583 INFO L273 TraceCheckUtils]: 231: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,583 INFO L273 TraceCheckUtils]: 230: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,583 INFO L273 TraceCheckUtils]: 229: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,583 INFO L256 TraceCheckUtils]: 228: Hoare triple {23233#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv13 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,586 INFO L273 TraceCheckUtils]: 227: Hoare triple {23267#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv14 32)))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {23233#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv13 32)))} is VALID [2018-11-23 11:34:53,586 INFO L268 TraceCheckUtils]: 226: Hoare quadruple {20764#true} {23267#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv14 32)))} #99#return; {23267#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv14 32)))} is VALID [2018-11-23 11:34:53,587 INFO L273 TraceCheckUtils]: 225: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,587 INFO L273 TraceCheckUtils]: 224: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,587 INFO L273 TraceCheckUtils]: 223: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,587 INFO L256 TraceCheckUtils]: 222: Hoare triple {23267#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv14 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,588 INFO L268 TraceCheckUtils]: 221: Hoare quadruple {20764#true} {23267#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv14 32)))} #97#return; {23267#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv14 32)))} is VALID [2018-11-23 11:34:53,588 INFO L273 TraceCheckUtils]: 220: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,588 INFO L273 TraceCheckUtils]: 219: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,588 INFO L273 TraceCheckUtils]: 218: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,589 INFO L256 TraceCheckUtils]: 217: Hoare triple {23267#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv14 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,589 INFO L268 TraceCheckUtils]: 216: Hoare quadruple {20764#true} {23267#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv14 32)))} #95#return; {23267#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv14 32)))} is VALID [2018-11-23 11:34:53,590 INFO L273 TraceCheckUtils]: 215: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,590 INFO L273 TraceCheckUtils]: 214: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,590 INFO L273 TraceCheckUtils]: 213: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,590 INFO L256 TraceCheckUtils]: 212: Hoare triple {23267#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv14 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,590 INFO L268 TraceCheckUtils]: 211: Hoare quadruple {20764#true} {23267#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv14 32)))} #93#return; {23267#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv14 32)))} is VALID [2018-11-23 11:34:53,591 INFO L273 TraceCheckUtils]: 210: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,591 INFO L273 TraceCheckUtils]: 209: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,591 INFO L273 TraceCheckUtils]: 208: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,591 INFO L256 TraceCheckUtils]: 207: Hoare triple {23267#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv14 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,593 INFO L273 TraceCheckUtils]: 206: Hoare triple {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {23267#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv14 32)))} is VALID [2018-11-23 11:34:53,594 INFO L268 TraceCheckUtils]: 205: Hoare quadruple {20764#true} {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} #91#return; {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} is VALID [2018-11-23 11:34:53,594 INFO L273 TraceCheckUtils]: 204: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,594 INFO L273 TraceCheckUtils]: 203: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,594 INFO L273 TraceCheckUtils]: 202: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,594 INFO L256 TraceCheckUtils]: 201: Hoare triple {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,595 INFO L268 TraceCheckUtils]: 200: Hoare quadruple {20764#true} {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} #89#return; {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} is VALID [2018-11-23 11:34:53,595 INFO L273 TraceCheckUtils]: 199: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,595 INFO L273 TraceCheckUtils]: 198: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,595 INFO L273 TraceCheckUtils]: 197: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,595 INFO L256 TraceCheckUtils]: 196: Hoare triple {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,596 INFO L268 TraceCheckUtils]: 195: Hoare quadruple {20764#true} {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} #87#return; {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} is VALID [2018-11-23 11:34:53,596 INFO L273 TraceCheckUtils]: 194: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,596 INFO L273 TraceCheckUtils]: 193: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,597 INFO L273 TraceCheckUtils]: 192: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,597 INFO L256 TraceCheckUtils]: 191: Hoare triple {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,598 INFO L268 TraceCheckUtils]: 190: Hoare quadruple {20764#true} {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} #85#return; {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} is VALID [2018-11-23 11:34:53,598 INFO L273 TraceCheckUtils]: 189: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,598 INFO L273 TraceCheckUtils]: 188: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,598 INFO L273 TraceCheckUtils]: 187: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,598 INFO L256 TraceCheckUtils]: 186: Hoare triple {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,599 INFO L273 TraceCheckUtils]: 185: Hoare triple {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} is VALID [2018-11-23 11:34:53,600 INFO L268 TraceCheckUtils]: 184: Hoare quadruple {20764#true} {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} #83#return; {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} is VALID [2018-11-23 11:34:53,600 INFO L273 TraceCheckUtils]: 183: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,600 INFO L273 TraceCheckUtils]: 182: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,600 INFO L273 TraceCheckUtils]: 181: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,600 INFO L256 TraceCheckUtils]: 180: Hoare triple {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,601 INFO L268 TraceCheckUtils]: 179: Hoare quadruple {20764#true} {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} #81#return; {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} is VALID [2018-11-23 11:34:53,602 INFO L273 TraceCheckUtils]: 178: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,602 INFO L273 TraceCheckUtils]: 177: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,602 INFO L273 TraceCheckUtils]: 176: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,602 INFO L256 TraceCheckUtils]: 175: Hoare triple {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,603 INFO L273 TraceCheckUtils]: 174: Hoare triple {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} is VALID [2018-11-23 11:34:53,603 INFO L273 TraceCheckUtils]: 173: Hoare triple {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} is VALID [2018-11-23 11:34:53,606 INFO L273 TraceCheckUtils]: 172: Hoare triple {23434#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv16 32)))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {23331#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv15 32)))} is VALID [2018-11-23 11:34:53,607 INFO L268 TraceCheckUtils]: 171: Hoare quadruple {20764#true} {23434#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv16 32)))} #103#return; {23434#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv16 32)))} is VALID [2018-11-23 11:34:53,607 INFO L273 TraceCheckUtils]: 170: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,607 INFO L273 TraceCheckUtils]: 169: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,607 INFO L273 TraceCheckUtils]: 168: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,608 INFO L256 TraceCheckUtils]: 167: Hoare triple {23434#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv16 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,608 INFO L268 TraceCheckUtils]: 166: Hoare quadruple {20764#true} {23434#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv16 32)))} #101#return; {23434#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv16 32)))} is VALID [2018-11-23 11:34:53,608 INFO L273 TraceCheckUtils]: 165: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,608 INFO L273 TraceCheckUtils]: 164: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,608 INFO L273 TraceCheckUtils]: 163: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,608 INFO L256 TraceCheckUtils]: 162: Hoare triple {23434#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv16 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,613 INFO L273 TraceCheckUtils]: 161: Hoare triple {23468#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv17 32)))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {23434#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv16 32)))} is VALID [2018-11-23 11:34:53,614 INFO L268 TraceCheckUtils]: 160: Hoare quadruple {20764#true} {23468#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv17 32)))} #99#return; {23468#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv17 32)))} is VALID [2018-11-23 11:34:53,614 INFO L273 TraceCheckUtils]: 159: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,614 INFO L273 TraceCheckUtils]: 158: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,614 INFO L273 TraceCheckUtils]: 157: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,615 INFO L256 TraceCheckUtils]: 156: Hoare triple {23468#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv17 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,636 INFO L268 TraceCheckUtils]: 155: Hoare quadruple {20764#true} {23468#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv17 32)))} #97#return; {23468#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv17 32)))} is VALID [2018-11-23 11:34:53,636 INFO L273 TraceCheckUtils]: 154: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,636 INFO L273 TraceCheckUtils]: 153: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,637 INFO L273 TraceCheckUtils]: 152: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,637 INFO L256 TraceCheckUtils]: 151: Hoare triple {23468#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv17 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,644 INFO L268 TraceCheckUtils]: 150: Hoare quadruple {20764#true} {23468#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv17 32)))} #95#return; {23468#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv17 32)))} is VALID [2018-11-23 11:34:53,644 INFO L273 TraceCheckUtils]: 149: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,644 INFO L273 TraceCheckUtils]: 148: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,644 INFO L273 TraceCheckUtils]: 147: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,644 INFO L256 TraceCheckUtils]: 146: Hoare triple {23468#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv17 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,645 INFO L268 TraceCheckUtils]: 145: Hoare quadruple {20764#true} {23468#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv17 32)))} #93#return; {23468#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv17 32)))} is VALID [2018-11-23 11:34:53,645 INFO L273 TraceCheckUtils]: 144: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,645 INFO L273 TraceCheckUtils]: 143: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,645 INFO L273 TraceCheckUtils]: 142: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,645 INFO L256 TraceCheckUtils]: 141: Hoare triple {23468#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv17 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,649 INFO L273 TraceCheckUtils]: 140: Hoare triple {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {23468#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv17 32)))} is VALID [2018-11-23 11:34:53,650 INFO L268 TraceCheckUtils]: 139: Hoare quadruple {20764#true} {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} #91#return; {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} is VALID [2018-11-23 11:34:53,650 INFO L273 TraceCheckUtils]: 138: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,650 INFO L273 TraceCheckUtils]: 137: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,650 INFO L273 TraceCheckUtils]: 136: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,651 INFO L256 TraceCheckUtils]: 135: Hoare triple {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,651 INFO L268 TraceCheckUtils]: 134: Hoare quadruple {20764#true} {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} #89#return; {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} is VALID [2018-11-23 11:34:53,651 INFO L273 TraceCheckUtils]: 133: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,651 INFO L273 TraceCheckUtils]: 132: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,651 INFO L273 TraceCheckUtils]: 131: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,652 INFO L256 TraceCheckUtils]: 130: Hoare triple {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,652 INFO L268 TraceCheckUtils]: 129: Hoare quadruple {20764#true} {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} #87#return; {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} is VALID [2018-11-23 11:34:53,652 INFO L273 TraceCheckUtils]: 128: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,652 INFO L273 TraceCheckUtils]: 127: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,652 INFO L273 TraceCheckUtils]: 126: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,652 INFO L256 TraceCheckUtils]: 125: Hoare triple {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,653 INFO L268 TraceCheckUtils]: 124: Hoare quadruple {20764#true} {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} #85#return; {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} is VALID [2018-11-23 11:34:53,653 INFO L273 TraceCheckUtils]: 123: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,654 INFO L273 TraceCheckUtils]: 122: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,654 INFO L273 TraceCheckUtils]: 121: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,654 INFO L256 TraceCheckUtils]: 120: Hoare triple {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,654 INFO L273 TraceCheckUtils]: 119: Hoare triple {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} is VALID [2018-11-23 11:34:53,655 INFO L268 TraceCheckUtils]: 118: Hoare quadruple {20764#true} {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} #83#return; {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} is VALID [2018-11-23 11:34:53,655 INFO L273 TraceCheckUtils]: 117: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,655 INFO L273 TraceCheckUtils]: 116: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,655 INFO L273 TraceCheckUtils]: 115: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,655 INFO L256 TraceCheckUtils]: 114: Hoare triple {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,656 INFO L268 TraceCheckUtils]: 113: Hoare quadruple {20764#true} {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} #81#return; {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} is VALID [2018-11-23 11:34:53,656 INFO L273 TraceCheckUtils]: 112: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,656 INFO L273 TraceCheckUtils]: 111: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,656 INFO L273 TraceCheckUtils]: 110: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,656 INFO L256 TraceCheckUtils]: 109: Hoare triple {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,656 INFO L273 TraceCheckUtils]: 108: Hoare triple {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} is VALID [2018-11-23 11:34:53,657 INFO L273 TraceCheckUtils]: 107: Hoare triple {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} is VALID [2018-11-23 11:34:53,661 INFO L273 TraceCheckUtils]: 106: Hoare triple {23635#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv19 32)))} #t~post8 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post8);havoc #t~post8; {23532#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv18 32)))} is VALID [2018-11-23 11:34:53,661 INFO L268 TraceCheckUtils]: 105: Hoare quadruple {20764#true} {23635#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv19 32)))} #103#return; {23635#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv19 32)))} is VALID [2018-11-23 11:34:53,662 INFO L273 TraceCheckUtils]: 104: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,662 INFO L273 TraceCheckUtils]: 103: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,662 INFO L273 TraceCheckUtils]: 102: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,662 INFO L256 TraceCheckUtils]: 101: Hoare triple {23635#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv19 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,663 INFO L268 TraceCheckUtils]: 100: Hoare quadruple {20764#true} {23635#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv19 32)))} #101#return; {23635#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv19 32)))} is VALID [2018-11-23 11:34:53,663 INFO L273 TraceCheckUtils]: 99: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,663 INFO L273 TraceCheckUtils]: 98: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,663 INFO L273 TraceCheckUtils]: 97: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,663 INFO L256 TraceCheckUtils]: 96: Hoare triple {23635#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv19 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,666 INFO L273 TraceCheckUtils]: 95: Hoare triple {23669#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv20 32)))} #t~post6 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post6);havoc #t~post6;#t~post7 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post7);havoc #t~post7; {23635#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv19 32)))} is VALID [2018-11-23 11:34:53,667 INFO L268 TraceCheckUtils]: 94: Hoare quadruple {20764#true} {23669#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv20 32)))} #99#return; {23669#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv20 32)))} is VALID [2018-11-23 11:34:53,667 INFO L273 TraceCheckUtils]: 93: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,668 INFO L273 TraceCheckUtils]: 92: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,668 INFO L273 TraceCheckUtils]: 91: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,668 INFO L256 TraceCheckUtils]: 90: Hoare triple {23669#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv20 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,668 INFO L268 TraceCheckUtils]: 89: Hoare quadruple {20764#true} {23669#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv20 32)))} #97#return; {23669#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv20 32)))} is VALID [2018-11-23 11:34:53,668 INFO L273 TraceCheckUtils]: 88: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,669 INFO L273 TraceCheckUtils]: 87: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,669 INFO L273 TraceCheckUtils]: 86: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,669 INFO L256 TraceCheckUtils]: 85: Hoare triple {23669#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv20 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,669 INFO L268 TraceCheckUtils]: 84: Hoare quadruple {20764#true} {23669#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv20 32)))} #95#return; {23669#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv20 32)))} is VALID [2018-11-23 11:34:53,669 INFO L273 TraceCheckUtils]: 83: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,670 INFO L273 TraceCheckUtils]: 82: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,670 INFO L273 TraceCheckUtils]: 81: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,670 INFO L256 TraceCheckUtils]: 80: Hoare triple {23669#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv20 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,671 INFO L268 TraceCheckUtils]: 79: Hoare quadruple {20764#true} {23669#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv20 32)))} #93#return; {23669#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv20 32)))} is VALID [2018-11-23 11:34:53,671 INFO L273 TraceCheckUtils]: 78: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,671 INFO L273 TraceCheckUtils]: 77: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,671 INFO L273 TraceCheckUtils]: 76: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,671 INFO L256 TraceCheckUtils]: 75: Hoare triple {23669#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv20 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,675 INFO L273 TraceCheckUtils]: 74: Hoare triple {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} #t~post4 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post4);havoc #t~post4;#t~post5 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post5);havoc #t~post5; {23669#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv20 32)))} is VALID [2018-11-23 11:34:53,676 INFO L268 TraceCheckUtils]: 73: Hoare quadruple {20764#true} {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} #91#return; {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} is VALID [2018-11-23 11:34:53,676 INFO L273 TraceCheckUtils]: 72: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,676 INFO L273 TraceCheckUtils]: 71: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,676 INFO L273 TraceCheckUtils]: 70: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,676 INFO L256 TraceCheckUtils]: 69: Hoare triple {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,677 INFO L268 TraceCheckUtils]: 68: Hoare quadruple {20764#true} {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} #89#return; {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} is VALID [2018-11-23 11:34:53,677 INFO L273 TraceCheckUtils]: 67: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,677 INFO L273 TraceCheckUtils]: 66: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,677 INFO L273 TraceCheckUtils]: 65: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,677 INFO L256 TraceCheckUtils]: 64: Hoare triple {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,678 INFO L268 TraceCheckUtils]: 63: Hoare quadruple {20764#true} {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} #87#return; {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} is VALID [2018-11-23 11:34:53,678 INFO L273 TraceCheckUtils]: 62: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,678 INFO L273 TraceCheckUtils]: 61: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,679 INFO L273 TraceCheckUtils]: 60: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,679 INFO L256 TraceCheckUtils]: 59: Hoare triple {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,679 INFO L268 TraceCheckUtils]: 58: Hoare quadruple {20764#true} {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} #85#return; {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} is VALID [2018-11-23 11:34:53,680 INFO L273 TraceCheckUtils]: 57: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,680 INFO L273 TraceCheckUtils]: 56: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,680 INFO L273 TraceCheckUtils]: 55: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,680 INFO L256 TraceCheckUtils]: 54: Hoare triple {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,680 INFO L273 TraceCheckUtils]: 53: Hoare triple {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} assume !(0bv32 != #t~nondet3);havoc #t~nondet3; {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} is VALID [2018-11-23 11:34:53,681 INFO L268 TraceCheckUtils]: 52: Hoare quadruple {20764#true} {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} #83#return; {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} is VALID [2018-11-23 11:34:53,681 INFO L273 TraceCheckUtils]: 51: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,681 INFO L273 TraceCheckUtils]: 50: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,681 INFO L273 TraceCheckUtils]: 49: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,681 INFO L256 TraceCheckUtils]: 48: Hoare triple {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,682 INFO L268 TraceCheckUtils]: 47: Hoare quadruple {20764#true} {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} #81#return; {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} is VALID [2018-11-23 11:34:53,682 INFO L273 TraceCheckUtils]: 46: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,682 INFO L273 TraceCheckUtils]: 45: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,682 INFO L273 TraceCheckUtils]: 44: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,682 INFO L256 TraceCheckUtils]: 43: Hoare triple {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,682 INFO L273 TraceCheckUtils]: 42: Hoare triple {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} is VALID [2018-11-23 11:34:53,683 INFO L273 TraceCheckUtils]: 41: Hoare triple {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} is VALID [2018-11-23 11:34:53,689 INFO L273 TraceCheckUtils]: 40: Hoare triple {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} #t~post9 := ~j~0;~j~0 := ~bvadd32(1bv32, #t~post9);havoc #t~post9;#t~post10 := ~i~0;~i~0 := ~bvadd32(1bv32, #t~post10);havoc #t~post10; {23733#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv21 32)))} is VALID [2018-11-23 11:34:53,689 INFO L268 TraceCheckUtils]: 39: Hoare quadruple {20764#true} {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} #111#return; {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} is VALID [2018-11-23 11:34:53,689 INFO L273 TraceCheckUtils]: 38: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,690 INFO L273 TraceCheckUtils]: 37: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,690 INFO L273 TraceCheckUtils]: 36: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,690 INFO L256 TraceCheckUtils]: 35: Hoare triple {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~j~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,690 INFO L268 TraceCheckUtils]: 34: Hoare quadruple {20764#true} {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} #109#return; {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} is VALID [2018-11-23 11:34:53,690 INFO L273 TraceCheckUtils]: 33: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,691 INFO L273 TraceCheckUtils]: 32: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,691 INFO L273 TraceCheckUtils]: 31: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,691 INFO L256 TraceCheckUtils]: 30: Hoare triple {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} call __VERIFIER_assert((if ~bvslt32(~j~0, ~bufsize~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,691 INFO L268 TraceCheckUtils]: 29: Hoare quadruple {20764#true} {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} #107#return; {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} is VALID [2018-11-23 11:34:53,691 INFO L273 TraceCheckUtils]: 28: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,691 INFO L273 TraceCheckUtils]: 27: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,692 INFO L273 TraceCheckUtils]: 26: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,692 INFO L256 TraceCheckUtils]: 25: Hoare triple {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,692 INFO L268 TraceCheckUtils]: 24: Hoare quadruple {20764#true} {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} #105#return; {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} is VALID [2018-11-23 11:34:53,693 INFO L273 TraceCheckUtils]: 23: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,693 INFO L273 TraceCheckUtils]: 22: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,693 INFO L273 TraceCheckUtils]: 21: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,693 INFO L256 TraceCheckUtils]: 20: Hoare triple {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} call __VERIFIER_assert((if ~bvslt32(~i~0, ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,694 INFO L273 TraceCheckUtils]: 19: Hoare triple {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} assume 0bv32 != #t~nondet3;havoc #t~nondet3; {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} is VALID [2018-11-23 11:34:53,695 INFO L268 TraceCheckUtils]: 18: Hoare quadruple {20764#true} {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} #83#return; {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} is VALID [2018-11-23 11:34:53,695 INFO L273 TraceCheckUtils]: 17: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,695 INFO L273 TraceCheckUtils]: 16: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,695 INFO L273 TraceCheckUtils]: 15: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,695 INFO L256 TraceCheckUtils]: 14: Hoare triple {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} call __VERIFIER_assert((if ~bvsle32(0bv32, ~i~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,696 INFO L268 TraceCheckUtils]: 13: Hoare quadruple {20764#true} {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} #81#return; {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} is VALID [2018-11-23 11:34:53,696 INFO L273 TraceCheckUtils]: 12: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,697 INFO L273 TraceCheckUtils]: 11: Hoare triple {20764#true} assume !(0bv32 == ~cond); {20764#true} is VALID [2018-11-23 11:34:53,697 INFO L273 TraceCheckUtils]: 10: Hoare triple {20764#true} ~cond := #in~cond; {20764#true} is VALID [2018-11-23 11:34:53,697 INFO L256 TraceCheckUtils]: 9: Hoare triple {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} call __VERIFIER_assert((if ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0) then 1bv32 else 0bv32)); {20764#true} is VALID [2018-11-23 11:34:53,697 INFO L273 TraceCheckUtils]: 8: Hoare triple {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} assume ~bvslt32(~bvadd32(1bv32, ~i~0), ~len~0); {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} is VALID [2018-11-23 11:34:53,698 INFO L273 TraceCheckUtils]: 7: Hoare triple {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} assume !!(~bvslt32(~i~0, ~len~0) && ~bvslt32(~j~0, ~limit~0)); {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} is VALID [2018-11-23 11:34:53,699 INFO L273 TraceCheckUtils]: 6: Hoare triple {20764#true} assume !!~bvslt32(~i~0, ~len~0);~j~0 := 0bv32; {23836#(bvsle (_ bv0 32) (bvadd main_~j~0 (_ bv22 32)))} is VALID [2018-11-23 11:34:53,699 INFO L273 TraceCheckUtils]: 5: Hoare triple {20764#true} assume !~bvslt32(~bufsize~0, 0bv32);~len~0 := #t~nondet2;havoc #t~nondet2;~limit~0 := ~bvsub32(~bufsize~0, 4bv32);~i~0 := 0bv32; {20764#true} is VALID [2018-11-23 11:34:53,699 INFO L273 TraceCheckUtils]: 4: Hoare triple {20764#true} havoc ~len~0;havoc ~i~0;havoc ~j~0;havoc ~bufsize~0;~bufsize~0 := #t~nondet1;havoc #t~nondet1; {20764#true} is VALID [2018-11-23 11:34:53,699 INFO L256 TraceCheckUtils]: 3: Hoare triple {20764#true} call #t~ret11 := main(); {20764#true} is VALID [2018-11-23 11:34:53,700 INFO L268 TraceCheckUtils]: 2: Hoare quadruple {20764#true} {20764#true} #77#return; {20764#true} is VALID [2018-11-23 11:34:53,700 INFO L273 TraceCheckUtils]: 1: Hoare triple {20764#true} assume true; {20764#true} is VALID [2018-11-23 11:34:53,700 INFO L256 TraceCheckUtils]: 0: Hoare triple {20764#true} call ULTIMATE.init(); {20764#true} is VALID [2018-11-23 11:34:53,876 INFO L134 CoverageAnalysis]: Checked inductivity of 17731 backedges. 186 proven. 433 refuted. 0 times theorem prover too weak. 17112 trivial. 0 not checked. [2018-11-23 11:34:53,879 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 11:34:53,879 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [27, 27] total 52 [2018-11-23 11:34:53,882 INFO L78 Accepts]: Start accepts. Automaton has 52 states. Word has length 524 [2018-11-23 11:34:53,883 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 11:34:53,883 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 52 states. [2018-11-23 11:34:54,762 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 486 edges. 486 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 11:34:54,762 INFO L459 AbstractCegarLoop]: Interpolant automaton has 52 states [2018-11-23 11:34:54,763 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 52 interpolants. [2018-11-23 11:34:54,765 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=632, Invalid=2020, Unknown=0, NotChecked=0, Total=2652 [2018-11-23 11:34:54,765 INFO L87 Difference]: Start difference. First operand 856 states and 1449 transitions. Second operand 52 states.