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_Default.epf -i ../../../trunk/examples/svcomp/array-examples/standard_two_index_09_true-unreach-call.i -------------------------------------------------------------------------------- This is Ultimate 0.1.23-61f4311 [2018-11-23 12:09:31,998 INFO L170 SettingsManager]: Resetting all preferences to default values... [2018-11-23 12:09:32,003 INFO L174 SettingsManager]: Resetting UltimateCore preferences to default values [2018-11-23 12:09:32,019 INFO L177 SettingsManager]: Ultimate Commandline Interface provides no preferences, ignoring... [2018-11-23 12:09:32,020 INFO L174 SettingsManager]: Resetting Boogie Preprocessor preferences to default values [2018-11-23 12:09:32,021 INFO L174 SettingsManager]: Resetting Boogie Procedure Inliner preferences to default values [2018-11-23 12:09:32,022 INFO L174 SettingsManager]: Resetting Abstract Interpretation preferences to default values [2018-11-23 12:09:32,025 INFO L174 SettingsManager]: Resetting LassoRanker preferences to default values [2018-11-23 12:09:32,028 INFO L174 SettingsManager]: Resetting Reaching Definitions preferences to default values [2018-11-23 12:09:32,029 INFO L174 SettingsManager]: Resetting SyntaxChecker preferences to default values [2018-11-23 12:09:32,029 INFO L177 SettingsManager]: Büchi Program Product provides no preferences, ignoring... [2018-11-23 12:09:32,031 INFO L174 SettingsManager]: Resetting LTL2Aut preferences to default values [2018-11-23 12:09:32,032 INFO L174 SettingsManager]: Resetting PEA to Boogie preferences to default values [2018-11-23 12:09:32,035 INFO L174 SettingsManager]: Resetting BlockEncodingV2 preferences to default values [2018-11-23 12:09:32,041 INFO L174 SettingsManager]: Resetting ChcToBoogie preferences to default values [2018-11-23 12:09:32,042 INFO L174 SettingsManager]: Resetting AutomataScriptInterpreter preferences to default values [2018-11-23 12:09:32,043 INFO L174 SettingsManager]: Resetting BuchiAutomizer preferences to default values [2018-11-23 12:09:32,050 INFO L174 SettingsManager]: Resetting CACSL2BoogieTranslator preferences to default values [2018-11-23 12:09:32,053 INFO L174 SettingsManager]: Resetting CodeCheck preferences to default values [2018-11-23 12:09:32,055 INFO L174 SettingsManager]: Resetting InvariantSynthesis preferences to default values [2018-11-23 12:09:32,056 INFO L174 SettingsManager]: Resetting RCFGBuilder preferences to default values [2018-11-23 12:09:32,060 INFO L174 SettingsManager]: Resetting TraceAbstraction preferences to default values [2018-11-23 12:09:32,063 INFO L177 SettingsManager]: TraceAbstractionConcurrent provides no preferences, ignoring... [2018-11-23 12:09:32,063 INFO L177 SettingsManager]: TraceAbstractionWithAFAs provides no preferences, ignoring... [2018-11-23 12:09:32,063 INFO L174 SettingsManager]: Resetting TreeAutomizer preferences to default values [2018-11-23 12:09:32,065 INFO L174 SettingsManager]: Resetting IcfgTransformer preferences to default values [2018-11-23 12:09:32,066 INFO L174 SettingsManager]: Resetting Boogie Printer preferences to default values [2018-11-23 12:09:32,067 INFO L174 SettingsManager]: Resetting ReqPrinter preferences to default values [2018-11-23 12:09:32,069 INFO L174 SettingsManager]: Resetting Witness Printer preferences to default values [2018-11-23 12:09:32,071 INFO L177 SettingsManager]: Boogie PL CUP Parser provides no preferences, ignoring... [2018-11-23 12:09:32,071 INFO L174 SettingsManager]: Resetting CDTParser preferences to default values [2018-11-23 12:09:32,072 INFO L177 SettingsManager]: AutomataScriptParser provides no preferences, ignoring... [2018-11-23 12:09:32,072 INFO L177 SettingsManager]: ReqParser provides no preferences, ignoring... [2018-11-23 12:09:32,072 INFO L174 SettingsManager]: Resetting SmtParser preferences to default values [2018-11-23 12:09:32,075 INFO L174 SettingsManager]: Resetting Witness Parser preferences to default values [2018-11-23 12:09:32,076 INFO L181 SettingsManager]: Finished resetting all preferences to default values... [2018-11-23 12:09:32,076 INFO L98 SettingsManager]: Beginning loading settings from /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/../../../trunk/examples/settings/default/automizer/svcomp-Reach-32bit-Automizer_Default.epf [2018-11-23 12:09:32,101 INFO L110 SettingsManager]: Loading preferences was successful [2018-11-23 12:09:32,101 INFO L112 SettingsManager]: Preferences different from defaults after loading the file: [2018-11-23 12:09:32,102 INFO L131 SettingsManager]: Preferences of Boogie Procedure Inliner differ from their defaults: [2018-11-23 12:09:32,102 INFO L133 SettingsManager]: * ... calls to implemented procedures=ONLY_FOR_CONCURRENT_PROGRAMS [2018-11-23 12:09:32,103 INFO L131 SettingsManager]: Preferences of BlockEncodingV2 differ from their defaults: [2018-11-23 12:09:32,103 INFO L133 SettingsManager]: * Create parallel compositions if possible=false [2018-11-23 12:09:32,103 INFO L133 SettingsManager]: * Use SBE=true [2018-11-23 12:09:32,103 INFO L131 SettingsManager]: Preferences of CACSL2BoogieTranslator differ from their defaults: [2018-11-23 12:09:32,104 INFO L133 SettingsManager]: * sizeof long=4 [2018-11-23 12:09:32,104 INFO L133 SettingsManager]: * Overapproximate operations on floating types=true [2018-11-23 12:09:32,104 INFO L133 SettingsManager]: * sizeof POINTER=4 [2018-11-23 12:09:32,104 INFO L133 SettingsManager]: * Check division by zero=IGNORE [2018-11-23 12:09:32,104 INFO L133 SettingsManager]: * Pointer to allocated memory at dereference=IGNORE [2018-11-23 12:09:32,104 INFO L133 SettingsManager]: * If two pointers are subtracted or compared they have the same base address=IGNORE [2018-11-23 12:09:32,105 INFO L133 SettingsManager]: * Check array bounds for arrays that are off heap=IGNORE [2018-11-23 12:09:32,105 INFO L133 SettingsManager]: * sizeof long double=12 [2018-11-23 12:09:32,105 INFO L133 SettingsManager]: * Check if freed pointer was valid=false [2018-11-23 12:09:32,105 INFO L133 SettingsManager]: * Use constant arrays=true [2018-11-23 12:09:32,105 INFO L133 SettingsManager]: * Pointer base address is valid at dereference=IGNORE [2018-11-23 12:09:32,106 INFO L131 SettingsManager]: Preferences of RCFGBuilder differ from their defaults: [2018-11-23 12:09:32,106 INFO L133 SettingsManager]: * Size of a code block=SequenceOfStatements [2018-11-23 12:09:32,106 INFO L133 SettingsManager]: * To the following directory=./dump/ [2018-11-23 12:09:32,106 INFO L133 SettingsManager]: * SMT solver=External_DefaultMode [2018-11-23 12:09:32,106 INFO L133 SettingsManager]: * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in -t:2000 [2018-11-23 12:09:32,107 INFO L131 SettingsManager]: Preferences of TraceAbstraction differ from their defaults: [2018-11-23 12:09:32,107 INFO L133 SettingsManager]: * Compute Interpolants along a Counterexample=FPandBP [2018-11-23 12:09:32,107 INFO L133 SettingsManager]: * Positions where we compute the Hoare Annotation=LoopsAndPotentialCycles [2018-11-23 12:09:32,107 INFO L133 SettingsManager]: * Trace refinement strategy=CAMEL [2018-11-23 12:09:32,107 INFO L133 SettingsManager]: * SMT solver=External_ModelsAndUnsatCoreMode [2018-11-23 12:09:32,108 INFO L133 SettingsManager]: * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in [2018-11-23 12:09:32,108 INFO L133 SettingsManager]: * Compute Hoare Annotation of negated interpolant automaton, abstraction and CFG=true [2018-11-23 12:09:32,157 INFO L81 nceAwareModelManager]: Repository-Root is: /tmp [2018-11-23 12:09:32,176 INFO L258 ainManager$Toolchain]: [Toolchain 1]: Applicable parser(s) successfully (re)initialized [2018-11-23 12:09:32,180 INFO L214 ainManager$Toolchain]: [Toolchain 1]: Toolchain selected. [2018-11-23 12:09:32,182 INFO L271 PluginConnector]: Initializing CDTParser... [2018-11-23 12:09:32,182 INFO L276 PluginConnector]: CDTParser initialized [2018-11-23 12:09:32,183 INFO L418 ainManager$Toolchain]: [Toolchain 1]: Parsing single file: /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/../../../trunk/examples/svcomp/array-examples/standard_two_index_09_true-unreach-call.i [2018-11-23 12:09:32,247 INFO L221 CDTParser]: Created temporary CDT project at /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/23c1322c8/39471af63ee2435a9390d8d3be519ef1/FLAG5abbc30bd [2018-11-23 12:09:32,707 INFO L307 CDTParser]: Found 1 translation units. [2018-11-23 12:09:32,708 INFO L161 CDTParser]: Scanning /storage/repos/ultimate/trunk/examples/svcomp/array-examples/standard_two_index_09_true-unreach-call.i [2018-11-23 12:09:32,714 INFO L355 CDTParser]: About to delete temporary CDT project at /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/23c1322c8/39471af63ee2435a9390d8d3be519ef1/FLAG5abbc30bd [2018-11-23 12:09:33,063 INFO L363 CDTParser]: Successfully deleted /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/23c1322c8/39471af63ee2435a9390d8d3be519ef1 [2018-11-23 12:09:33,072 INFO L296 ainManager$Toolchain]: ####################### [Toolchain 1] ####################### [2018-11-23 12:09:33,074 INFO L131 ToolchainWalker]: Walking toolchain with 6 elements. [2018-11-23 12:09:33,074 INFO L113 PluginConnector]: ------------------------CACSL2BoogieTranslator---------------------------- [2018-11-23 12:09:33,075 INFO L271 PluginConnector]: Initializing CACSL2BoogieTranslator... [2018-11-23 12:09:33,078 INFO L276 PluginConnector]: CACSL2BoogieTranslator initialized [2018-11-23 12:09:33,080 INFO L185 PluginConnector]: Executing the observer ACSLObjectContainerObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 23.11 12:09:33" (1/1) ... [2018-11-23 12:09:33,083 INFO L205 PluginConnector]: Invalid model from CACSL2BoogieTranslator for observer de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator.ACSLObjectContainerObserver@7d0be90c and model type de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:33, skipping insertion in model container [2018-11-23 12:09:33,083 INFO L185 PluginConnector]: Executing the observer CACSL2BoogieTranslatorObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 23.11 12:09:33" (1/1) ... [2018-11-23 12:09:33,093 INFO L145 MainTranslator]: Starting translation in SV-COMP mode [2018-11-23 12:09:33,114 INFO L176 MainTranslator]: Built tables and reachable declarations [2018-11-23 12:09:33,313 INFO L201 PostProcessor]: Analyzing one entry point: main [2018-11-23 12:09:33,317 INFO L191 MainTranslator]: Completed pre-run [2018-11-23 12:09:33,344 INFO L201 PostProcessor]: Analyzing one entry point: main [2018-11-23 12:09:33,368 INFO L195 MainTranslator]: Completed translation [2018-11-23 12:09:33,369 INFO L202 PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:33 WrapperNode [2018-11-23 12:09:33,369 INFO L132 PluginConnector]: ------------------------ END CACSL2BoogieTranslator---------------------------- [2018-11-23 12:09:33,370 INFO L113 PluginConnector]: ------------------------Boogie Procedure Inliner---------------------------- [2018-11-23 12:09:33,370 INFO L271 PluginConnector]: Initializing Boogie Procedure Inliner... [2018-11-23 12:09:33,370 INFO L276 PluginConnector]: Boogie Procedure Inliner initialized [2018-11-23 12:09:33,380 INFO L185 PluginConnector]: Executing the observer TypeChecker from plugin Boogie Procedure Inliner for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:33" (1/1) ... [2018-11-23 12:09:33,390 INFO L185 PluginConnector]: Executing the observer Inliner from plugin Boogie Procedure Inliner for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:33" (1/1) ... [2018-11-23 12:09:33,399 INFO L132 PluginConnector]: ------------------------ END Boogie Procedure Inliner---------------------------- [2018-11-23 12:09:33,399 INFO L113 PluginConnector]: ------------------------Boogie Preprocessor---------------------------- [2018-11-23 12:09:33,400 INFO L271 PluginConnector]: Initializing Boogie Preprocessor... [2018-11-23 12:09:33,400 INFO L276 PluginConnector]: Boogie Preprocessor initialized [2018-11-23 12:09:33,411 INFO L185 PluginConnector]: Executing the observer EnsureBoogieModelObserver from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:33" (1/1) ... [2018-11-23 12:09:33,411 INFO L185 PluginConnector]: Executing the observer TypeChecker from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:33" (1/1) ... [2018-11-23 12:09:33,413 INFO L185 PluginConnector]: Executing the observer ConstExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:33" (1/1) ... [2018-11-23 12:09:33,413 INFO L185 PluginConnector]: Executing the observer StructExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:33" (1/1) ... [2018-11-23 12:09:33,433 INFO L185 PluginConnector]: Executing the observer UnstructureCode from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:33" (1/1) ... [2018-11-23 12:09:33,444 INFO L185 PluginConnector]: Executing the observer FunctionInliner from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:33" (1/1) ... [2018-11-23 12:09:33,446 INFO L185 PluginConnector]: Executing the observer BoogieSymbolTableConstructor from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:33" (1/1) ... [2018-11-23 12:09:33,449 INFO L132 PluginConnector]: ------------------------ END Boogie Preprocessor---------------------------- [2018-11-23 12:09:33,450 INFO L113 PluginConnector]: ------------------------RCFGBuilder---------------------------- [2018-11-23 12:09:33,450 INFO L271 PluginConnector]: Initializing RCFGBuilder... [2018-11-23 12:09:33,450 INFO L276 PluginConnector]: RCFGBuilder initialized [2018-11-23 12:09:33,452 INFO L185 PluginConnector]: Executing the observer RCFGBuilderObserver from plugin RCFGBuilder for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:33" (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 12:09:33,585 INFO L130 BoogieDeclarations]: Found specification of procedure write~int [2018-11-23 12:09:33,585 INFO L130 BoogieDeclarations]: Found specification of procedure ULTIMATE.init [2018-11-23 12:09:33,585 INFO L138 BoogieDeclarations]: Found implementation of procedure ULTIMATE.init [2018-11-23 12:09:33,585 INFO L130 BoogieDeclarations]: Found specification of procedure #Ultimate.alloc [2018-11-23 12:09:33,585 INFO L130 BoogieDeclarations]: Found specification of procedure ULTIMATE.start [2018-11-23 12:09:33,586 INFO L138 BoogieDeclarations]: Found implementation of procedure ULTIMATE.start [2018-11-23 12:09:33,586 INFO L130 BoogieDeclarations]: Found specification of procedure read~int [2018-11-23 12:09:33,586 INFO L130 BoogieDeclarations]: Found specification of procedure main [2018-11-23 12:09:33,586 INFO L138 BoogieDeclarations]: Found implementation of procedure main [2018-11-23 12:09:33,586 INFO L130 BoogieDeclarations]: Found specification of procedure __VERIFIER_assert [2018-11-23 12:09:33,586 INFO L138 BoogieDeclarations]: Found implementation of procedure __VERIFIER_assert [2018-11-23 12:09:33,587 INFO L130 BoogieDeclarations]: Found specification of procedure ULTIMATE.dealloc [2018-11-23 12:09:34,159 INFO L275 CfgBuilder]: Using the 1 location(s) as analysis (start of procedure ULTIMATE.start) [2018-11-23 12:09:34,159 INFO L280 CfgBuilder]: Removed 3 assue(true) statements. [2018-11-23 12:09:34,160 INFO L202 PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 23.11 12:09:34 BoogieIcfgContainer [2018-11-23 12:09:34,160 INFO L132 PluginConnector]: ------------------------ END RCFGBuilder---------------------------- [2018-11-23 12:09:34,161 INFO L113 PluginConnector]: ------------------------TraceAbstraction---------------------------- [2018-11-23 12:09:34,161 INFO L271 PluginConnector]: Initializing TraceAbstraction... [2018-11-23 12:09:34,164 INFO L276 PluginConnector]: TraceAbstraction initialized [2018-11-23 12:09:34,165 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "CDTParser AST 23.11 12:09:33" (1/3) ... [2018-11-23 12:09:34,166 INFO L205 PluginConnector]: Invalid model from TraceAbstraction for observer de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionObserver@26fb8fd5 and model type de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction AST 23.11 12:09:34, skipping insertion in model container [2018-11-23 12:09:34,166 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:33" (2/3) ... [2018-11-23 12:09:34,166 INFO L205 PluginConnector]: Invalid model from TraceAbstraction for observer de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionObserver@26fb8fd5 and model type de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction AST 23.11 12:09:34, skipping insertion in model container [2018-11-23 12:09:34,166 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 23.11 12:09:34" (3/3) ... [2018-11-23 12:09:34,168 INFO L112 eAbstractionObserver]: Analyzing ICFG standard_two_index_09_true-unreach-call.i [2018-11-23 12:09:34,179 INFO L156 ceAbstractionStarter]: Automizer settings: Hoare:true NWA Interpolation:FPandBP Determinization: PREDICATE_ABSTRACTION [2018-11-23 12:09:34,187 INFO L168 ceAbstractionStarter]: Appying trace abstraction to program that has 1 error locations. [2018-11-23 12:09:34,205 INFO L257 AbstractCegarLoop]: Starting to check reachability of 1 error locations. [2018-11-23 12:09:34,242 INFO L133 ementStrategyFactory]: Using default assertion order modulation [2018-11-23 12:09:34,243 INFO L382 AbstractCegarLoop]: Interprodecural is true [2018-11-23 12:09:34,243 INFO L383 AbstractCegarLoop]: Hoare is true [2018-11-23 12:09:34,243 INFO L384 AbstractCegarLoop]: Compute interpolants for FPandBP [2018-11-23 12:09:34,243 INFO L385 AbstractCegarLoop]: Backedges is STRAIGHT_LINE [2018-11-23 12:09:34,243 INFO L386 AbstractCegarLoop]: Determinization is PREDICATE_ABSTRACTION [2018-11-23 12:09:34,244 INFO L387 AbstractCegarLoop]: Difference is false [2018-11-23 12:09:34,244 INFO L388 AbstractCegarLoop]: Minimize is MINIMIZE_SEVPA [2018-11-23 12:09:34,244 INFO L393 AbstractCegarLoop]: ======== Iteration 0==of CEGAR loop == AllErrorsAtOnce======== [2018-11-23 12:09:34,261 INFO L276 IsEmpty]: Start isEmpty. Operand 24 states. [2018-11-23 12:09:34,267 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 16 [2018-11-23 12:09:34,267 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:34,268 INFO L402 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:34,271 INFO L423 AbstractCegarLoop]: === Iteration 1 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:34,277 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:34,277 INFO L82 PathProgramCache]: Analyzing trace with hash -2029643862, now seen corresponding path program 1 times [2018-11-23 12:09:34,280 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:34,280 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:34,323 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:34,324 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:34,324 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:34,360 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:34,414 INFO L256 TraceCheckUtils]: 0: Hoare triple {27#true} call ULTIMATE.init(); {27#true} is VALID [2018-11-23 12:09:34,418 INFO L273 TraceCheckUtils]: 1: Hoare triple {27#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {27#true} is VALID [2018-11-23 12:09:34,419 INFO L273 TraceCheckUtils]: 2: Hoare triple {27#true} assume true; {27#true} is VALID [2018-11-23 12:09:34,419 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {27#true} {27#true} #60#return; {27#true} is VALID [2018-11-23 12:09:34,419 INFO L256 TraceCheckUtils]: 4: Hoare triple {27#true} call #t~ret4 := main(); {27#true} is VALID [2018-11-23 12:09:34,420 INFO L273 TraceCheckUtils]: 5: Hoare triple {27#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {27#true} is VALID [2018-11-23 12:09:34,421 INFO L273 TraceCheckUtils]: 6: Hoare triple {27#true} assume !true; {28#false} is VALID [2018-11-23 12:09:34,421 INFO L273 TraceCheckUtils]: 7: Hoare triple {28#false} ~i~0 := 1; {28#false} is VALID [2018-11-23 12:09:34,422 INFO L273 TraceCheckUtils]: 8: Hoare triple {28#false} assume !(~i~0 < 100000); {28#false} is VALID [2018-11-23 12:09:34,422 INFO L273 TraceCheckUtils]: 9: Hoare triple {28#false} ~i~0 := 1;~j~0 := 0; {28#false} is VALID [2018-11-23 12:09:34,422 INFO L273 TraceCheckUtils]: 10: Hoare triple {28#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {28#false} is VALID [2018-11-23 12:09:34,423 INFO L256 TraceCheckUtils]: 11: Hoare triple {28#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {28#false} is VALID [2018-11-23 12:09:34,423 INFO L273 TraceCheckUtils]: 12: Hoare triple {28#false} ~cond := #in~cond; {28#false} is VALID [2018-11-23 12:09:34,424 INFO L273 TraceCheckUtils]: 13: Hoare triple {28#false} assume 0 == ~cond; {28#false} is VALID [2018-11-23 12:09:34,424 INFO L273 TraceCheckUtils]: 14: Hoare triple {28#false} assume !false; {28#false} is VALID [2018-11-23 12:09:34,427 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 12:09:34,430 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 12:09:34,430 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [2] imperfect sequences [] total 2 [2018-11-23 12:09:34,435 INFO L78 Accepts]: Start accepts. Automaton has 2 states. Word has length 15 [2018-11-23 12:09:34,438 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:34,441 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 2 states. [2018-11-23 12:09:34,546 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 15 edges. 15 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:34,546 INFO L459 AbstractCegarLoop]: Interpolant automaton has 2 states [2018-11-23 12:09:34,554 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 2 interpolants. [2018-11-23 12:09:34,554 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1, Invalid=1, Unknown=0, NotChecked=0, Total=2 [2018-11-23 12:09:34,557 INFO L87 Difference]: Start difference. First operand 24 states. Second operand 2 states. [2018-11-23 12:09:34,791 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:34,791 INFO L93 Difference]: Finished difference Result 41 states and 52 transitions. [2018-11-23 12:09:34,791 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 2 states. [2018-11-23 12:09:34,791 INFO L78 Accepts]: Start accepts. Automaton has 2 states. Word has length 15 [2018-11-23 12:09:34,792 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:34,793 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 2 states. [2018-11-23 12:09:34,804 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 2 states to 2 states and 52 transitions. [2018-11-23 12:09:34,804 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 2 states. [2018-11-23 12:09:34,808 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 2 states to 2 states and 52 transitions. [2018-11-23 12:09:34,809 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 2 states and 52 transitions. [2018-11-23 12:09:35,064 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 52 edges. 52 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:35,073 INFO L225 Difference]: With dead ends: 41 [2018-11-23 12:09:35,073 INFO L226 Difference]: Without dead ends: 19 [2018-11-23 12:09:35,078 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 2 GetRequests, 2 SyntacticMatches, 0 SemanticMatches, 0 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=1, Invalid=1, Unknown=0, NotChecked=0, Total=2 [2018-11-23 12:09:35,095 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 19 states. [2018-11-23 12:09:35,122 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 19 to 19. [2018-11-23 12:09:35,122 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:35,122 INFO L82 GeneralOperation]: Start isEquivalent. First operand 19 states. Second operand 19 states. [2018-11-23 12:09:35,123 INFO L74 IsIncluded]: Start isIncluded. First operand 19 states. Second operand 19 states. [2018-11-23 12:09:35,123 INFO L87 Difference]: Start difference. First operand 19 states. Second operand 19 states. [2018-11-23 12:09:35,126 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:35,126 INFO L93 Difference]: Finished difference Result 19 states and 21 transitions. [2018-11-23 12:09:35,127 INFO L276 IsEmpty]: Start isEmpty. Operand 19 states and 21 transitions. [2018-11-23 12:09:35,127 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:35,127 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:35,127 INFO L74 IsIncluded]: Start isIncluded. First operand 19 states. Second operand 19 states. [2018-11-23 12:09:35,128 INFO L87 Difference]: Start difference. First operand 19 states. Second operand 19 states. [2018-11-23 12:09:35,131 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:35,131 INFO L93 Difference]: Finished difference Result 19 states and 21 transitions. [2018-11-23 12:09:35,133 INFO L276 IsEmpty]: Start isEmpty. Operand 19 states and 21 transitions. [2018-11-23 12:09:35,133 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:35,133 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:35,134 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:35,134 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:35,134 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 19 states. [2018-11-23 12:09:35,136 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 19 states to 19 states and 21 transitions. [2018-11-23 12:09:35,137 INFO L78 Accepts]: Start accepts. Automaton has 19 states and 21 transitions. Word has length 15 [2018-11-23 12:09:35,137 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:35,138 INFO L480 AbstractCegarLoop]: Abstraction has 19 states and 21 transitions. [2018-11-23 12:09:35,138 INFO L481 AbstractCegarLoop]: Interpolant automaton has 2 states. [2018-11-23 12:09:35,138 INFO L276 IsEmpty]: Start isEmpty. Operand 19 states and 21 transitions. [2018-11-23 12:09:35,139 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 16 [2018-11-23 12:09:35,139 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:35,139 INFO L402 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:35,139 INFO L423 AbstractCegarLoop]: === Iteration 2 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:35,140 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:35,140 INFO L82 PathProgramCache]: Analyzing trace with hash 905206694, now seen corresponding path program 1 times [2018-11-23 12:09:35,140 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:35,140 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:35,141 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:35,141 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:35,141 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:35,162 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:35,238 INFO L256 TraceCheckUtils]: 0: Hoare triple {151#true} call ULTIMATE.init(); {151#true} is VALID [2018-11-23 12:09:35,239 INFO L273 TraceCheckUtils]: 1: Hoare triple {151#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {151#true} is VALID [2018-11-23 12:09:35,239 INFO L273 TraceCheckUtils]: 2: Hoare triple {151#true} assume true; {151#true} is VALID [2018-11-23 12:09:35,239 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {151#true} {151#true} #60#return; {151#true} is VALID [2018-11-23 12:09:35,239 INFO L256 TraceCheckUtils]: 4: Hoare triple {151#true} call #t~ret4 := main(); {151#true} is VALID [2018-11-23 12:09:35,241 INFO L273 TraceCheckUtils]: 5: Hoare triple {151#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {153#(= main_~i~0 0)} is VALID [2018-11-23 12:09:35,244 INFO L273 TraceCheckUtils]: 6: Hoare triple {153#(= main_~i~0 0)} assume !(~i~0 < 100000); {152#false} is VALID [2018-11-23 12:09:35,244 INFO L273 TraceCheckUtils]: 7: Hoare triple {152#false} ~i~0 := 1; {152#false} is VALID [2018-11-23 12:09:35,245 INFO L273 TraceCheckUtils]: 8: Hoare triple {152#false} assume !(~i~0 < 100000); {152#false} is VALID [2018-11-23 12:09:35,245 INFO L273 TraceCheckUtils]: 9: Hoare triple {152#false} ~i~0 := 1;~j~0 := 0; {152#false} is VALID [2018-11-23 12:09:35,245 INFO L273 TraceCheckUtils]: 10: Hoare triple {152#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {152#false} is VALID [2018-11-23 12:09:35,246 INFO L256 TraceCheckUtils]: 11: Hoare triple {152#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {152#false} is VALID [2018-11-23 12:09:35,246 INFO L273 TraceCheckUtils]: 12: Hoare triple {152#false} ~cond := #in~cond; {152#false} is VALID [2018-11-23 12:09:35,246 INFO L273 TraceCheckUtils]: 13: Hoare triple {152#false} assume 0 == ~cond; {152#false} is VALID [2018-11-23 12:09:35,247 INFO L273 TraceCheckUtils]: 14: Hoare triple {152#false} assume !false; {152#false} is VALID [2018-11-23 12:09:35,248 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 12:09:35,248 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 12:09:35,249 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [3] imperfect sequences [] total 3 [2018-11-23 12:09:35,250 INFO L78 Accepts]: Start accepts. Automaton has 3 states. Word has length 15 [2018-11-23 12:09:35,250 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:35,251 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 3 states. [2018-11-23 12:09:35,381 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 15 edges. 15 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:35,381 INFO L459 AbstractCegarLoop]: Interpolant automaton has 3 states [2018-11-23 12:09:35,381 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 3 interpolants. [2018-11-23 12:09:35,381 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=3, Invalid=3, Unknown=0, NotChecked=0, Total=6 [2018-11-23 12:09:35,382 INFO L87 Difference]: Start difference. First operand 19 states and 21 transitions. Second operand 3 states. [2018-11-23 12:09:35,546 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:35,546 INFO L93 Difference]: Finished difference Result 32 states and 36 transitions. [2018-11-23 12:09:35,546 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 3 states. [2018-11-23 12:09:35,546 INFO L78 Accepts]: Start accepts. Automaton has 3 states. Word has length 15 [2018-11-23 12:09:35,547 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:35,547 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 3 states. [2018-11-23 12:09:35,550 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 3 states to 3 states and 36 transitions. [2018-11-23 12:09:35,550 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 3 states. [2018-11-23 12:09:35,552 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 3 states to 3 states and 36 transitions. [2018-11-23 12:09:35,552 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 3 states and 36 transitions. [2018-11-23 12:09:35,613 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 36 edges. 36 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:35,615 INFO L225 Difference]: With dead ends: 32 [2018-11-23 12:09:35,615 INFO L226 Difference]: Without dead ends: 20 [2018-11-23 12:09:35,618 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 3 GetRequests, 2 SyntacticMatches, 0 SemanticMatches, 1 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=3, Invalid=3, Unknown=0, NotChecked=0, Total=6 [2018-11-23 12:09:35,618 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 20 states. [2018-11-23 12:09:35,632 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 20 to 20. [2018-11-23 12:09:35,633 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:35,633 INFO L82 GeneralOperation]: Start isEquivalent. First operand 20 states. Second operand 20 states. [2018-11-23 12:09:35,633 INFO L74 IsIncluded]: Start isIncluded. First operand 20 states. Second operand 20 states. [2018-11-23 12:09:35,633 INFO L87 Difference]: Start difference. First operand 20 states. Second operand 20 states. [2018-11-23 12:09:35,635 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:35,635 INFO L93 Difference]: Finished difference Result 20 states and 22 transitions. [2018-11-23 12:09:35,635 INFO L276 IsEmpty]: Start isEmpty. Operand 20 states and 22 transitions. [2018-11-23 12:09:35,636 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:35,636 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:35,636 INFO L74 IsIncluded]: Start isIncluded. First operand 20 states. Second operand 20 states. [2018-11-23 12:09:35,636 INFO L87 Difference]: Start difference. First operand 20 states. Second operand 20 states. [2018-11-23 12:09:35,638 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:35,638 INFO L93 Difference]: Finished difference Result 20 states and 22 transitions. [2018-11-23 12:09:35,639 INFO L276 IsEmpty]: Start isEmpty. Operand 20 states and 22 transitions. [2018-11-23 12:09:35,639 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:35,639 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:35,640 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:35,640 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:35,640 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 20 states. [2018-11-23 12:09:35,641 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 20 states to 20 states and 22 transitions. [2018-11-23 12:09:35,642 INFO L78 Accepts]: Start accepts. Automaton has 20 states and 22 transitions. Word has length 15 [2018-11-23 12:09:35,642 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:35,642 INFO L480 AbstractCegarLoop]: Abstraction has 20 states and 22 transitions. [2018-11-23 12:09:35,642 INFO L481 AbstractCegarLoop]: Interpolant automaton has 3 states. [2018-11-23 12:09:35,642 INFO L276 IsEmpty]: Start isEmpty. Operand 20 states and 22 transitions. [2018-11-23 12:09:35,643 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 17 [2018-11-23 12:09:35,643 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:35,643 INFO L402 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:35,644 INFO L423 AbstractCegarLoop]: === Iteration 3 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:35,644 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:35,644 INFO L82 PathProgramCache]: Analyzing trace with hash -764882998, now seen corresponding path program 1 times [2018-11-23 12:09:35,644 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:35,644 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:35,645 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:35,645 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:35,645 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:35,661 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:35,787 INFO L256 TraceCheckUtils]: 0: Hoare triple {272#true} call ULTIMATE.init(); {272#true} is VALID [2018-11-23 12:09:35,787 INFO L273 TraceCheckUtils]: 1: Hoare triple {272#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {272#true} is VALID [2018-11-23 12:09:35,788 INFO L273 TraceCheckUtils]: 2: Hoare triple {272#true} assume true; {272#true} is VALID [2018-11-23 12:09:35,788 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {272#true} {272#true} #60#return; {272#true} is VALID [2018-11-23 12:09:35,788 INFO L256 TraceCheckUtils]: 4: Hoare triple {272#true} call #t~ret4 := main(); {272#true} is VALID [2018-11-23 12:09:35,789 INFO L273 TraceCheckUtils]: 5: Hoare triple {272#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {272#true} is VALID [2018-11-23 12:09:35,789 INFO L273 TraceCheckUtils]: 6: Hoare triple {272#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {272#true} is VALID [2018-11-23 12:09:35,790 INFO L273 TraceCheckUtils]: 7: Hoare triple {272#true} assume !(~i~0 < 100000); {272#true} is VALID [2018-11-23 12:09:35,802 INFO L273 TraceCheckUtils]: 8: Hoare triple {272#true} ~i~0 := 1; {274#(= main_~i~0 1)} is VALID [2018-11-23 12:09:35,816 INFO L273 TraceCheckUtils]: 9: Hoare triple {274#(= main_~i~0 1)} assume !(~i~0 < 100000); {273#false} is VALID [2018-11-23 12:09:35,816 INFO L273 TraceCheckUtils]: 10: Hoare triple {273#false} ~i~0 := 1;~j~0 := 0; {273#false} is VALID [2018-11-23 12:09:35,816 INFO L273 TraceCheckUtils]: 11: Hoare triple {273#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {273#false} is VALID [2018-11-23 12:09:35,817 INFO L256 TraceCheckUtils]: 12: Hoare triple {273#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {273#false} is VALID [2018-11-23 12:09:35,817 INFO L273 TraceCheckUtils]: 13: Hoare triple {273#false} ~cond := #in~cond; {273#false} is VALID [2018-11-23 12:09:35,817 INFO L273 TraceCheckUtils]: 14: Hoare triple {273#false} assume 0 == ~cond; {273#false} is VALID [2018-11-23 12:09:35,818 INFO L273 TraceCheckUtils]: 15: Hoare triple {273#false} assume !false; {273#false} is VALID [2018-11-23 12:09:35,819 INFO L134 CoverageAnalysis]: Checked inductivity of 1 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 1 trivial. 0 not checked. [2018-11-23 12:09:35,819 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 12:09:35,820 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [3] imperfect sequences [] total 3 [2018-11-23 12:09:35,820 INFO L78 Accepts]: Start accepts. Automaton has 3 states. Word has length 16 [2018-11-23 12:09:35,820 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:35,821 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 3 states. [2018-11-23 12:09:36,027 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 16 edges. 16 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:36,027 INFO L459 AbstractCegarLoop]: Interpolant automaton has 3 states [2018-11-23 12:09:36,028 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 3 interpolants. [2018-11-23 12:09:36,028 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=3, Invalid=3, Unknown=0, NotChecked=0, Total=6 [2018-11-23 12:09:36,028 INFO L87 Difference]: Start difference. First operand 20 states and 22 transitions. Second operand 3 states. [2018-11-23 12:09:36,182 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:36,183 INFO L93 Difference]: Finished difference Result 34 states and 38 transitions. [2018-11-23 12:09:36,183 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 3 states. [2018-11-23 12:09:36,183 INFO L78 Accepts]: Start accepts. Automaton has 3 states. Word has length 16 [2018-11-23 12:09:36,183 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:36,183 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 3 states. [2018-11-23 12:09:36,186 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 3 states to 3 states and 37 transitions. [2018-11-23 12:09:36,186 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 3 states. [2018-11-23 12:09:36,189 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 3 states to 3 states and 37 transitions. [2018-11-23 12:09:36,189 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 3 states and 37 transitions. [2018-11-23 12:09:36,371 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 37 edges. 37 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:36,374 INFO L225 Difference]: With dead ends: 34 [2018-11-23 12:09:36,374 INFO L226 Difference]: Without dead ends: 24 [2018-11-23 12:09:36,375 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 3 GetRequests, 2 SyntacticMatches, 0 SemanticMatches, 1 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=3, Invalid=3, Unknown=0, NotChecked=0, Total=6 [2018-11-23 12:09:36,375 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 24 states. [2018-11-23 12:09:36,427 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 24 to 21. [2018-11-23 12:09:36,427 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:36,427 INFO L82 GeneralOperation]: Start isEquivalent. First operand 24 states. Second operand 21 states. [2018-11-23 12:09:36,427 INFO L74 IsIncluded]: Start isIncluded. First operand 24 states. Second operand 21 states. [2018-11-23 12:09:36,428 INFO L87 Difference]: Start difference. First operand 24 states. Second operand 21 states. [2018-11-23 12:09:36,431 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:36,431 INFO L93 Difference]: Finished difference Result 24 states and 27 transitions. [2018-11-23 12:09:36,431 INFO L276 IsEmpty]: Start isEmpty. Operand 24 states and 27 transitions. [2018-11-23 12:09:36,432 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:36,432 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:36,433 INFO L74 IsIncluded]: Start isIncluded. First operand 21 states. Second operand 24 states. [2018-11-23 12:09:36,433 INFO L87 Difference]: Start difference. First operand 21 states. Second operand 24 states. [2018-11-23 12:09:36,435 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:36,435 INFO L93 Difference]: Finished difference Result 24 states and 27 transitions. [2018-11-23 12:09:36,435 INFO L276 IsEmpty]: Start isEmpty. Operand 24 states and 27 transitions. [2018-11-23 12:09:36,436 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:36,436 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:36,437 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:36,437 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:36,437 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 21 states. [2018-11-23 12:09:36,438 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 21 states to 21 states and 23 transitions. [2018-11-23 12:09:36,439 INFO L78 Accepts]: Start accepts. Automaton has 21 states and 23 transitions. Word has length 16 [2018-11-23 12:09:36,439 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:36,439 INFO L480 AbstractCegarLoop]: Abstraction has 21 states and 23 transitions. [2018-11-23 12:09:36,439 INFO L481 AbstractCegarLoop]: Interpolant automaton has 3 states. [2018-11-23 12:09:36,440 INFO L276 IsEmpty]: Start isEmpty. Operand 21 states and 23 transitions. [2018-11-23 12:09:36,440 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 18 [2018-11-23 12:09:36,440 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:36,441 INFO L402 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:36,441 INFO L423 AbstractCegarLoop]: === Iteration 4 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:36,441 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:36,441 INFO L82 PathProgramCache]: Analyzing trace with hash -59429947, now seen corresponding path program 1 times [2018-11-23 12:09:36,441 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:36,442 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:36,443 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:36,443 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:36,443 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:36,469 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:36,563 INFO L256 TraceCheckUtils]: 0: Hoare triple {407#true} call ULTIMATE.init(); {407#true} is VALID [2018-11-23 12:09:36,563 INFO L273 TraceCheckUtils]: 1: Hoare triple {407#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {407#true} is VALID [2018-11-23 12:09:36,564 INFO L273 TraceCheckUtils]: 2: Hoare triple {407#true} assume true; {407#true} is VALID [2018-11-23 12:09:36,564 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {407#true} {407#true} #60#return; {407#true} is VALID [2018-11-23 12:09:36,564 INFO L256 TraceCheckUtils]: 4: Hoare triple {407#true} call #t~ret4 := main(); {407#true} is VALID [2018-11-23 12:09:36,568 INFO L273 TraceCheckUtils]: 5: Hoare triple {407#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {409#(= main_~i~0 0)} is VALID [2018-11-23 12:09:36,569 INFO L273 TraceCheckUtils]: 6: Hoare triple {409#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {410#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:36,571 INFO L273 TraceCheckUtils]: 7: Hoare triple {410#(<= main_~i~0 1)} assume !(~i~0 < 100000); {408#false} is VALID [2018-11-23 12:09:36,571 INFO L273 TraceCheckUtils]: 8: Hoare triple {408#false} ~i~0 := 1; {408#false} is VALID [2018-11-23 12:09:36,571 INFO L273 TraceCheckUtils]: 9: Hoare triple {408#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {408#false} is VALID [2018-11-23 12:09:36,572 INFO L273 TraceCheckUtils]: 10: Hoare triple {408#false} assume !(~i~0 < 100000); {408#false} is VALID [2018-11-23 12:09:36,572 INFO L273 TraceCheckUtils]: 11: Hoare triple {408#false} ~i~0 := 1;~j~0 := 0; {408#false} is VALID [2018-11-23 12:09:36,572 INFO L273 TraceCheckUtils]: 12: Hoare triple {408#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {408#false} is VALID [2018-11-23 12:09:36,573 INFO L256 TraceCheckUtils]: 13: Hoare triple {408#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {408#false} is VALID [2018-11-23 12:09:36,573 INFO L273 TraceCheckUtils]: 14: Hoare triple {408#false} ~cond := #in~cond; {408#false} is VALID [2018-11-23 12:09:36,573 INFO L273 TraceCheckUtils]: 15: Hoare triple {408#false} assume 0 == ~cond; {408#false} is VALID [2018-11-23 12:09:36,574 INFO L273 TraceCheckUtils]: 16: Hoare triple {408#false} assume !false; {408#false} is VALID [2018-11-23 12:09:36,575 INFO L134 CoverageAnalysis]: Checked inductivity of 2 backedges. 0 proven. 1 refuted. 0 times theorem prover too weak. 1 trivial. 0 not checked. [2018-11-23 12:09:36,575 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:36,575 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 2 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 2 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:36,588 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:36,608 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:36,636 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:36,640 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:36,909 INFO L256 TraceCheckUtils]: 0: Hoare triple {407#true} call ULTIMATE.init(); {407#true} is VALID [2018-11-23 12:09:36,909 INFO L273 TraceCheckUtils]: 1: Hoare triple {407#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {407#true} is VALID [2018-11-23 12:09:36,910 INFO L273 TraceCheckUtils]: 2: Hoare triple {407#true} assume true; {407#true} is VALID [2018-11-23 12:09:36,910 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {407#true} {407#true} #60#return; {407#true} is VALID [2018-11-23 12:09:36,910 INFO L256 TraceCheckUtils]: 4: Hoare triple {407#true} call #t~ret4 := main(); {407#true} is VALID [2018-11-23 12:09:36,911 INFO L273 TraceCheckUtils]: 5: Hoare triple {407#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {429#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:36,915 INFO L273 TraceCheckUtils]: 6: Hoare triple {429#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {410#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:36,916 INFO L273 TraceCheckUtils]: 7: Hoare triple {410#(<= main_~i~0 1)} assume !(~i~0 < 100000); {408#false} is VALID [2018-11-23 12:09:36,916 INFO L273 TraceCheckUtils]: 8: Hoare triple {408#false} ~i~0 := 1; {408#false} is VALID [2018-11-23 12:09:36,917 INFO L273 TraceCheckUtils]: 9: Hoare triple {408#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {408#false} is VALID [2018-11-23 12:09:36,917 INFO L273 TraceCheckUtils]: 10: Hoare triple {408#false} assume !(~i~0 < 100000); {408#false} is VALID [2018-11-23 12:09:36,917 INFO L273 TraceCheckUtils]: 11: Hoare triple {408#false} ~i~0 := 1;~j~0 := 0; {408#false} is VALID [2018-11-23 12:09:36,917 INFO L273 TraceCheckUtils]: 12: Hoare triple {408#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {408#false} is VALID [2018-11-23 12:09:36,918 INFO L256 TraceCheckUtils]: 13: Hoare triple {408#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {408#false} is VALID [2018-11-23 12:09:36,918 INFO L273 TraceCheckUtils]: 14: Hoare triple {408#false} ~cond := #in~cond; {408#false} is VALID [2018-11-23 12:09:36,918 INFO L273 TraceCheckUtils]: 15: Hoare triple {408#false} assume 0 == ~cond; {408#false} is VALID [2018-11-23 12:09:36,918 INFO L273 TraceCheckUtils]: 16: Hoare triple {408#false} assume !false; {408#false} is VALID [2018-11-23 12:09:36,919 INFO L134 CoverageAnalysis]: Checked inductivity of 2 backedges. 0 proven. 1 refuted. 0 times theorem prover too weak. 1 trivial. 0 not checked. [2018-11-23 12:09:36,939 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:36,939 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [4, 4] total 5 [2018-11-23 12:09:36,940 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 17 [2018-11-23 12:09:36,941 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:36,941 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states. [2018-11-23 12:09:36,990 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 19 edges. 19 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:36,990 INFO L459 AbstractCegarLoop]: Interpolant automaton has 5 states [2018-11-23 12:09:36,991 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 5 interpolants. [2018-11-23 12:09:36,991 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=10, Invalid=10, Unknown=0, NotChecked=0, Total=20 [2018-11-23 12:09:36,991 INFO L87 Difference]: Start difference. First operand 21 states and 23 transitions. Second operand 5 states. [2018-11-23 12:09:37,255 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:37,255 INFO L93 Difference]: Finished difference Result 38 states and 43 transitions. [2018-11-23 12:09:37,255 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 4 states. [2018-11-23 12:09:37,255 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 17 [2018-11-23 12:09:37,256 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:37,256 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 12:09:37,258 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 4 states to 4 states and 42 transitions. [2018-11-23 12:09:37,259 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 12:09:37,261 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 4 states to 4 states and 42 transitions. [2018-11-23 12:09:37,262 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 4 states and 42 transitions. [2018-11-23 12:09:37,389 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 42 edges. 42 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:37,391 INFO L225 Difference]: With dead ends: 38 [2018-11-23 12:09:37,391 INFO L226 Difference]: Without dead ends: 25 [2018-11-23 12:09:37,391 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 20 GetRequests, 17 SyntacticMatches, 0 SemanticMatches, 3 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=10, Invalid=10, Unknown=0, NotChecked=0, Total=20 [2018-11-23 12:09:37,392 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 25 states. [2018-11-23 12:09:37,441 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 25 to 22. [2018-11-23 12:09:37,441 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:37,441 INFO L82 GeneralOperation]: Start isEquivalent. First operand 25 states. Second operand 22 states. [2018-11-23 12:09:37,442 INFO L74 IsIncluded]: Start isIncluded. First operand 25 states. Second operand 22 states. [2018-11-23 12:09:37,442 INFO L87 Difference]: Start difference. First operand 25 states. Second operand 22 states. [2018-11-23 12:09:37,444 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:37,444 INFO L93 Difference]: Finished difference Result 25 states and 28 transitions. [2018-11-23 12:09:37,444 INFO L276 IsEmpty]: Start isEmpty. Operand 25 states and 28 transitions. [2018-11-23 12:09:37,445 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:37,445 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:37,445 INFO L74 IsIncluded]: Start isIncluded. First operand 22 states. Second operand 25 states. [2018-11-23 12:09:37,446 INFO L87 Difference]: Start difference. First operand 22 states. Second operand 25 states. [2018-11-23 12:09:37,448 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:37,449 INFO L93 Difference]: Finished difference Result 25 states and 28 transitions. [2018-11-23 12:09:37,449 INFO L276 IsEmpty]: Start isEmpty. Operand 25 states and 28 transitions. [2018-11-23 12:09:37,449 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:37,450 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:37,450 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:37,450 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:37,450 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 22 states. [2018-11-23 12:09:37,452 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 22 states to 22 states and 24 transitions. [2018-11-23 12:09:37,453 INFO L78 Accepts]: Start accepts. Automaton has 22 states and 24 transitions. Word has length 17 [2018-11-23 12:09:37,453 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:37,453 INFO L480 AbstractCegarLoop]: Abstraction has 22 states and 24 transitions. [2018-11-23 12:09:37,453 INFO L481 AbstractCegarLoop]: Interpolant automaton has 5 states. [2018-11-23 12:09:37,453 INFO L276 IsEmpty]: Start isEmpty. Operand 22 states and 24 transitions. [2018-11-23 12:09:37,454 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 19 [2018-11-23 12:09:37,454 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:37,454 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 12:09:37,455 INFO L423 AbstractCegarLoop]: === Iteration 5 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:37,455 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:37,455 INFO L82 PathProgramCache]: Analyzing trace with hash 1302144745, now seen corresponding path program 2 times [2018-11-23 12:09:37,455 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:37,455 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:37,456 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:37,457 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:37,457 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:37,481 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:37,566 INFO L256 TraceCheckUtils]: 0: Hoare triple {603#true} call ULTIMATE.init(); {603#true} is VALID [2018-11-23 12:09:37,567 INFO L273 TraceCheckUtils]: 1: Hoare triple {603#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {603#true} is VALID [2018-11-23 12:09:37,567 INFO L273 TraceCheckUtils]: 2: Hoare triple {603#true} assume true; {603#true} is VALID [2018-11-23 12:09:37,567 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {603#true} {603#true} #60#return; {603#true} is VALID [2018-11-23 12:09:37,568 INFO L256 TraceCheckUtils]: 4: Hoare triple {603#true} call #t~ret4 := main(); {603#true} is VALID [2018-11-23 12:09:37,576 INFO L273 TraceCheckUtils]: 5: Hoare triple {603#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {605#(= main_~i~0 0)} is VALID [2018-11-23 12:09:37,587 INFO L273 TraceCheckUtils]: 6: Hoare triple {605#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {606#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:37,588 INFO L273 TraceCheckUtils]: 7: Hoare triple {606#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {607#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:37,588 INFO L273 TraceCheckUtils]: 8: Hoare triple {607#(<= main_~i~0 2)} assume !(~i~0 < 100000); {604#false} is VALID [2018-11-23 12:09:37,589 INFO L273 TraceCheckUtils]: 9: Hoare triple {604#false} ~i~0 := 1; {604#false} is VALID [2018-11-23 12:09:37,589 INFO L273 TraceCheckUtils]: 10: Hoare triple {604#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {604#false} is VALID [2018-11-23 12:09:37,589 INFO L273 TraceCheckUtils]: 11: Hoare triple {604#false} assume !(~i~0 < 100000); {604#false} is VALID [2018-11-23 12:09:37,589 INFO L273 TraceCheckUtils]: 12: Hoare triple {604#false} ~i~0 := 1;~j~0 := 0; {604#false} is VALID [2018-11-23 12:09:37,590 INFO L273 TraceCheckUtils]: 13: Hoare triple {604#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {604#false} is VALID [2018-11-23 12:09:37,590 INFO L256 TraceCheckUtils]: 14: Hoare triple {604#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {604#false} is VALID [2018-11-23 12:09:37,590 INFO L273 TraceCheckUtils]: 15: Hoare triple {604#false} ~cond := #in~cond; {604#false} is VALID [2018-11-23 12:09:37,590 INFO L273 TraceCheckUtils]: 16: Hoare triple {604#false} assume 0 == ~cond; {604#false} is VALID [2018-11-23 12:09:37,591 INFO L273 TraceCheckUtils]: 17: Hoare triple {604#false} assume !false; {604#false} is VALID [2018-11-23 12:09:37,592 INFO L134 CoverageAnalysis]: Checked inductivity of 4 backedges. 0 proven. 3 refuted. 0 times theorem prover too weak. 1 trivial. 0 not checked. [2018-11-23 12:09:37,592 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:37,592 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 3 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 3 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:37,601 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:09:37,624 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:09:37,624 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:37,641 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:37,642 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:37,778 INFO L256 TraceCheckUtils]: 0: Hoare triple {603#true} call ULTIMATE.init(); {603#true} is VALID [2018-11-23 12:09:37,778 INFO L273 TraceCheckUtils]: 1: Hoare triple {603#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {603#true} is VALID [2018-11-23 12:09:37,778 INFO L273 TraceCheckUtils]: 2: Hoare triple {603#true} assume true; {603#true} is VALID [2018-11-23 12:09:37,779 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {603#true} {603#true} #60#return; {603#true} is VALID [2018-11-23 12:09:37,779 INFO L256 TraceCheckUtils]: 4: Hoare triple {603#true} call #t~ret4 := main(); {603#true} is VALID [2018-11-23 12:09:37,784 INFO L273 TraceCheckUtils]: 5: Hoare triple {603#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {626#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:37,786 INFO L273 TraceCheckUtils]: 6: Hoare triple {626#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {606#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:37,791 INFO L273 TraceCheckUtils]: 7: Hoare triple {606#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {607#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:37,797 INFO L273 TraceCheckUtils]: 8: Hoare triple {607#(<= main_~i~0 2)} assume !(~i~0 < 100000); {604#false} is VALID [2018-11-23 12:09:37,797 INFO L273 TraceCheckUtils]: 9: Hoare triple {604#false} ~i~0 := 1; {604#false} is VALID [2018-11-23 12:09:37,797 INFO L273 TraceCheckUtils]: 10: Hoare triple {604#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {604#false} is VALID [2018-11-23 12:09:37,798 INFO L273 TraceCheckUtils]: 11: Hoare triple {604#false} assume !(~i~0 < 100000); {604#false} is VALID [2018-11-23 12:09:37,798 INFO L273 TraceCheckUtils]: 12: Hoare triple {604#false} ~i~0 := 1;~j~0 := 0; {604#false} is VALID [2018-11-23 12:09:37,798 INFO L273 TraceCheckUtils]: 13: Hoare triple {604#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {604#false} is VALID [2018-11-23 12:09:37,798 INFO L256 TraceCheckUtils]: 14: Hoare triple {604#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {604#false} is VALID [2018-11-23 12:09:37,799 INFO L273 TraceCheckUtils]: 15: Hoare triple {604#false} ~cond := #in~cond; {604#false} is VALID [2018-11-23 12:09:37,799 INFO L273 TraceCheckUtils]: 16: Hoare triple {604#false} assume 0 == ~cond; {604#false} is VALID [2018-11-23 12:09:37,799 INFO L273 TraceCheckUtils]: 17: Hoare triple {604#false} assume !false; {604#false} is VALID [2018-11-23 12:09:37,800 INFO L134 CoverageAnalysis]: Checked inductivity of 4 backedges. 0 proven. 3 refuted. 0 times theorem prover too weak. 1 trivial. 0 not checked. [2018-11-23 12:09:37,819 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:37,819 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [5, 5] total 6 [2018-11-23 12:09:37,820 INFO L78 Accepts]: Start accepts. Automaton has 6 states. Word has length 18 [2018-11-23 12:09:37,820 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:37,820 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 6 states. [2018-11-23 12:09:37,877 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 12:09:37,877 INFO L459 AbstractCegarLoop]: Interpolant automaton has 6 states [2018-11-23 12:09:37,877 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 6 interpolants. [2018-11-23 12:09:37,877 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=15, Invalid=15, Unknown=0, NotChecked=0, Total=30 [2018-11-23 12:09:37,878 INFO L87 Difference]: Start difference. First operand 22 states and 24 transitions. Second operand 6 states. [2018-11-23 12:09:38,105 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:38,106 INFO L93 Difference]: Finished difference Result 39 states and 44 transitions. [2018-11-23 12:09:38,106 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 5 states. [2018-11-23 12:09:38,107 INFO L78 Accepts]: Start accepts. Automaton has 6 states. Word has length 18 [2018-11-23 12:09:38,107 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:38,107 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 6 states. [2018-11-23 12:09:38,110 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 43 transitions. [2018-11-23 12:09:38,110 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 6 states. [2018-11-23 12:09:38,112 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 43 transitions. [2018-11-23 12:09:38,112 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states and 43 transitions. [2018-11-23 12:09:38,197 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 43 edges. 43 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:38,199 INFO L225 Difference]: With dead ends: 39 [2018-11-23 12:09:38,200 INFO L226 Difference]: Without dead ends: 26 [2018-11-23 12:09:38,200 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 22 GetRequests, 18 SyntacticMatches, 0 SemanticMatches, 4 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 2 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=15, Invalid=15, Unknown=0, NotChecked=0, Total=30 [2018-11-23 12:09:38,201 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 26 states. [2018-11-23 12:09:38,231 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 26 to 23. [2018-11-23 12:09:38,231 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:38,231 INFO L82 GeneralOperation]: Start isEquivalent. First operand 26 states. Second operand 23 states. [2018-11-23 12:09:38,231 INFO L74 IsIncluded]: Start isIncluded. First operand 26 states. Second operand 23 states. [2018-11-23 12:09:38,231 INFO L87 Difference]: Start difference. First operand 26 states. Second operand 23 states. [2018-11-23 12:09:38,233 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:38,234 INFO L93 Difference]: Finished difference Result 26 states and 29 transitions. [2018-11-23 12:09:38,234 INFO L276 IsEmpty]: Start isEmpty. Operand 26 states and 29 transitions. [2018-11-23 12:09:38,235 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:38,235 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:38,235 INFO L74 IsIncluded]: Start isIncluded. First operand 23 states. Second operand 26 states. [2018-11-23 12:09:38,235 INFO L87 Difference]: Start difference. First operand 23 states. Second operand 26 states. [2018-11-23 12:09:38,237 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:38,237 INFO L93 Difference]: Finished difference Result 26 states and 29 transitions. [2018-11-23 12:09:38,237 INFO L276 IsEmpty]: Start isEmpty. Operand 26 states and 29 transitions. [2018-11-23 12:09:38,238 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:38,238 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:38,238 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:38,239 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:38,239 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 23 states. [2018-11-23 12:09:38,240 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 23 states to 23 states and 25 transitions. [2018-11-23 12:09:38,240 INFO L78 Accepts]: Start accepts. Automaton has 23 states and 25 transitions. Word has length 18 [2018-11-23 12:09:38,240 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:38,241 INFO L480 AbstractCegarLoop]: Abstraction has 23 states and 25 transitions. [2018-11-23 12:09:38,241 INFO L481 AbstractCegarLoop]: Interpolant automaton has 6 states. [2018-11-23 12:09:38,241 INFO L276 IsEmpty]: Start isEmpty. Operand 23 states and 25 transitions. [2018-11-23 12:09:38,241 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 20 [2018-11-23 12:09:38,242 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:38,242 INFO L402 BasicCegarLoop]: trace histogram [3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:38,242 INFO L423 AbstractCegarLoop]: === Iteration 6 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:38,242 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:38,242 INFO L82 PathProgramCache]: Analyzing trace with hash 561287237, now seen corresponding path program 3 times [2018-11-23 12:09:38,243 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:38,243 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:38,244 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:38,244 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:38,244 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:38,262 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:38,355 INFO L256 TraceCheckUtils]: 0: Hoare triple {809#true} call ULTIMATE.init(); {809#true} is VALID [2018-11-23 12:09:38,356 INFO L273 TraceCheckUtils]: 1: Hoare triple {809#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {809#true} is VALID [2018-11-23 12:09:38,356 INFO L273 TraceCheckUtils]: 2: Hoare triple {809#true} assume true; {809#true} is VALID [2018-11-23 12:09:38,356 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {809#true} {809#true} #60#return; {809#true} is VALID [2018-11-23 12:09:38,357 INFO L256 TraceCheckUtils]: 4: Hoare triple {809#true} call #t~ret4 := main(); {809#true} is VALID [2018-11-23 12:09:38,371 INFO L273 TraceCheckUtils]: 5: Hoare triple {809#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {811#(= main_~i~0 0)} is VALID [2018-11-23 12:09:38,373 INFO L273 TraceCheckUtils]: 6: Hoare triple {811#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {812#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:38,374 INFO L273 TraceCheckUtils]: 7: Hoare triple {812#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {813#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:38,379 INFO L273 TraceCheckUtils]: 8: Hoare triple {813#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {814#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:38,380 INFO L273 TraceCheckUtils]: 9: Hoare triple {814#(<= main_~i~0 3)} assume !(~i~0 < 100000); {810#false} is VALID [2018-11-23 12:09:38,380 INFO L273 TraceCheckUtils]: 10: Hoare triple {810#false} ~i~0 := 1; {810#false} is VALID [2018-11-23 12:09:38,381 INFO L273 TraceCheckUtils]: 11: Hoare triple {810#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {810#false} is VALID [2018-11-23 12:09:38,381 INFO L273 TraceCheckUtils]: 12: Hoare triple {810#false} assume !(~i~0 < 100000); {810#false} is VALID [2018-11-23 12:09:38,382 INFO L273 TraceCheckUtils]: 13: Hoare triple {810#false} ~i~0 := 1;~j~0 := 0; {810#false} is VALID [2018-11-23 12:09:38,382 INFO L273 TraceCheckUtils]: 14: Hoare triple {810#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {810#false} is VALID [2018-11-23 12:09:38,383 INFO L256 TraceCheckUtils]: 15: Hoare triple {810#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {810#false} is VALID [2018-11-23 12:09:38,383 INFO L273 TraceCheckUtils]: 16: Hoare triple {810#false} ~cond := #in~cond; {810#false} is VALID [2018-11-23 12:09:38,384 INFO L273 TraceCheckUtils]: 17: Hoare triple {810#false} assume 0 == ~cond; {810#false} is VALID [2018-11-23 12:09:38,384 INFO L273 TraceCheckUtils]: 18: Hoare triple {810#false} assume !false; {810#false} is VALID [2018-11-23 12:09:38,385 INFO L134 CoverageAnalysis]: Checked inductivity of 7 backedges. 0 proven. 6 refuted. 0 times theorem prover too weak. 1 trivial. 0 not checked. [2018-11-23 12:09:38,385 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:38,386 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 4 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 4 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:38,396 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:09:38,413 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 2 check-sat command(s) [2018-11-23 12:09:38,414 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:38,428 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:38,429 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:38,503 INFO L256 TraceCheckUtils]: 0: Hoare triple {809#true} call ULTIMATE.init(); {809#true} is VALID [2018-11-23 12:09:38,503 INFO L273 TraceCheckUtils]: 1: Hoare triple {809#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {809#true} is VALID [2018-11-23 12:09:38,503 INFO L273 TraceCheckUtils]: 2: Hoare triple {809#true} assume true; {809#true} is VALID [2018-11-23 12:09:38,504 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {809#true} {809#true} #60#return; {809#true} is VALID [2018-11-23 12:09:38,504 INFO L256 TraceCheckUtils]: 4: Hoare triple {809#true} call #t~ret4 := main(); {809#true} is VALID [2018-11-23 12:09:38,504 INFO L273 TraceCheckUtils]: 5: Hoare triple {809#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {809#true} is VALID [2018-11-23 12:09:38,504 INFO L273 TraceCheckUtils]: 6: Hoare triple {809#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {809#true} is VALID [2018-11-23 12:09:38,504 INFO L273 TraceCheckUtils]: 7: Hoare triple {809#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {809#true} is VALID [2018-11-23 12:09:38,505 INFO L273 TraceCheckUtils]: 8: Hoare triple {809#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {809#true} is VALID [2018-11-23 12:09:38,505 INFO L273 TraceCheckUtils]: 9: Hoare triple {809#true} assume !(~i~0 < 100000); {809#true} is VALID [2018-11-23 12:09:38,505 INFO L273 TraceCheckUtils]: 10: Hoare triple {809#true} ~i~0 := 1; {812#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:38,509 INFO L273 TraceCheckUtils]: 11: Hoare triple {812#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {851#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:38,509 INFO L273 TraceCheckUtils]: 12: Hoare triple {851#(<= main_~i~0 10)} assume !(~i~0 < 100000); {810#false} is VALID [2018-11-23 12:09:38,510 INFO L273 TraceCheckUtils]: 13: Hoare triple {810#false} ~i~0 := 1;~j~0 := 0; {810#false} is VALID [2018-11-23 12:09:38,510 INFO L273 TraceCheckUtils]: 14: Hoare triple {810#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {810#false} is VALID [2018-11-23 12:09:38,510 INFO L256 TraceCheckUtils]: 15: Hoare triple {810#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {810#false} is VALID [2018-11-23 12:09:38,510 INFO L273 TraceCheckUtils]: 16: Hoare triple {810#false} ~cond := #in~cond; {810#false} is VALID [2018-11-23 12:09:38,510 INFO L273 TraceCheckUtils]: 17: Hoare triple {810#false} assume 0 == ~cond; {810#false} is VALID [2018-11-23 12:09:38,511 INFO L273 TraceCheckUtils]: 18: Hoare triple {810#false} assume !false; {810#false} is VALID [2018-11-23 12:09:38,511 INFO L134 CoverageAnalysis]: Checked inductivity of 7 backedges. 0 proven. 1 refuted. 0 times theorem prover too weak. 6 trivial. 0 not checked. [2018-11-23 12:09:38,530 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:38,530 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [6, 4] total 7 [2018-11-23 12:09:38,531 INFO L78 Accepts]: Start accepts. Automaton has 7 states. Word has length 19 [2018-11-23 12:09:38,531 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:38,531 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 7 states. [2018-11-23 12:09:38,577 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 25 edges. 25 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:38,577 INFO L459 AbstractCegarLoop]: Interpolant automaton has 7 states [2018-11-23 12:09:38,577 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 7 interpolants. [2018-11-23 12:09:38,578 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=21, Invalid=21, Unknown=0, NotChecked=0, Total=42 [2018-11-23 12:09:38,578 INFO L87 Difference]: Start difference. First operand 23 states and 25 transitions. Second operand 7 states. [2018-11-23 12:09:38,787 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:38,787 INFO L93 Difference]: Finished difference Result 45 states and 53 transitions. [2018-11-23 12:09:38,787 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 7 states. [2018-11-23 12:09:38,787 INFO L78 Accepts]: Start accepts. Automaton has 7 states. Word has length 19 [2018-11-23 12:09:38,788 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:38,788 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 7 states. [2018-11-23 12:09:38,790 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 7 states to 7 states and 52 transitions. [2018-11-23 12:09:38,791 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 7 states. [2018-11-23 12:09:38,793 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 7 states to 7 states and 52 transitions. [2018-11-23 12:09:38,793 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 7 states and 52 transitions. [2018-11-23 12:09:38,945 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 52 edges. 52 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:38,947 INFO L225 Difference]: With dead ends: 45 [2018-11-23 12:09:38,947 INFO L226 Difference]: Without dead ends: 32 [2018-11-23 12:09:38,948 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 24 GetRequests, 19 SyntacticMatches, 0 SemanticMatches, 5 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=21, Invalid=21, Unknown=0, NotChecked=0, Total=42 [2018-11-23 12:09:38,948 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 32 states. [2018-11-23 12:09:38,967 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 32 to 26. [2018-11-23 12:09:38,967 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:38,967 INFO L82 GeneralOperation]: Start isEquivalent. First operand 32 states. Second operand 26 states. [2018-11-23 12:09:38,967 INFO L74 IsIncluded]: Start isIncluded. First operand 32 states. Second operand 26 states. [2018-11-23 12:09:38,967 INFO L87 Difference]: Start difference. First operand 32 states. Second operand 26 states. [2018-11-23 12:09:38,969 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:38,970 INFO L93 Difference]: Finished difference Result 32 states and 36 transitions. [2018-11-23 12:09:38,970 INFO L276 IsEmpty]: Start isEmpty. Operand 32 states and 36 transitions. [2018-11-23 12:09:38,971 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:38,971 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:38,971 INFO L74 IsIncluded]: Start isIncluded. First operand 26 states. Second operand 32 states. [2018-11-23 12:09:38,971 INFO L87 Difference]: Start difference. First operand 26 states. Second operand 32 states. [2018-11-23 12:09:38,973 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:38,974 INFO L93 Difference]: Finished difference Result 32 states and 36 transitions. [2018-11-23 12:09:38,974 INFO L276 IsEmpty]: Start isEmpty. Operand 32 states and 36 transitions. [2018-11-23 12:09:38,974 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:38,975 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:38,975 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:38,975 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:38,975 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 26 states. [2018-11-23 12:09:38,976 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 26 states to 26 states and 28 transitions. [2018-11-23 12:09:38,977 INFO L78 Accepts]: Start accepts. Automaton has 26 states and 28 transitions. Word has length 19 [2018-11-23 12:09:38,977 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:38,977 INFO L480 AbstractCegarLoop]: Abstraction has 26 states and 28 transitions. [2018-11-23 12:09:38,977 INFO L481 AbstractCegarLoop]: Interpolant automaton has 7 states. [2018-11-23 12:09:38,977 INFO L276 IsEmpty]: Start isEmpty. Operand 26 states and 28 transitions. [2018-11-23 12:09:38,978 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 23 [2018-11-23 12:09:38,978 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:38,978 INFO L402 BasicCegarLoop]: trace histogram [5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:38,979 INFO L423 AbstractCegarLoop]: === Iteration 7 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:38,979 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:38,979 INFO L82 PathProgramCache]: Analyzing trace with hash 53593642, now seen corresponding path program 4 times [2018-11-23 12:09:38,979 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:38,979 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:38,980 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:38,980 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:38,980 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:39,002 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:39,153 INFO L256 TraceCheckUtils]: 0: Hoare triple {1048#true} call ULTIMATE.init(); {1048#true} is VALID [2018-11-23 12:09:39,154 INFO L273 TraceCheckUtils]: 1: Hoare triple {1048#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1048#true} is VALID [2018-11-23 12:09:39,154 INFO L273 TraceCheckUtils]: 2: Hoare triple {1048#true} assume true; {1048#true} is VALID [2018-11-23 12:09:39,154 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1048#true} {1048#true} #60#return; {1048#true} is VALID [2018-11-23 12:09:39,155 INFO L256 TraceCheckUtils]: 4: Hoare triple {1048#true} call #t~ret4 := main(); {1048#true} is VALID [2018-11-23 12:09:39,156 INFO L273 TraceCheckUtils]: 5: Hoare triple {1048#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {1050#(= main_~i~0 0)} is VALID [2018-11-23 12:09:39,161 INFO L273 TraceCheckUtils]: 6: Hoare triple {1050#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1051#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:39,162 INFO L273 TraceCheckUtils]: 7: Hoare triple {1051#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1052#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:39,163 INFO L273 TraceCheckUtils]: 8: Hoare triple {1052#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1053#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:39,163 INFO L273 TraceCheckUtils]: 9: Hoare triple {1053#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1054#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:39,164 INFO L273 TraceCheckUtils]: 10: Hoare triple {1054#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1055#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:39,165 INFO L273 TraceCheckUtils]: 11: Hoare triple {1055#(<= main_~i~0 5)} assume !(~i~0 < 100000); {1049#false} is VALID [2018-11-23 12:09:39,166 INFO L273 TraceCheckUtils]: 12: Hoare triple {1049#false} ~i~0 := 1; {1049#false} is VALID [2018-11-23 12:09:39,166 INFO L273 TraceCheckUtils]: 13: Hoare triple {1049#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1049#false} is VALID [2018-11-23 12:09:39,166 INFO L273 TraceCheckUtils]: 14: Hoare triple {1049#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1049#false} is VALID [2018-11-23 12:09:39,167 INFO L273 TraceCheckUtils]: 15: Hoare triple {1049#false} assume !(~i~0 < 100000); {1049#false} is VALID [2018-11-23 12:09:39,167 INFO L273 TraceCheckUtils]: 16: Hoare triple {1049#false} ~i~0 := 1;~j~0 := 0; {1049#false} is VALID [2018-11-23 12:09:39,167 INFO L273 TraceCheckUtils]: 17: Hoare triple {1049#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {1049#false} is VALID [2018-11-23 12:09:39,168 INFO L256 TraceCheckUtils]: 18: Hoare triple {1049#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {1049#false} is VALID [2018-11-23 12:09:39,168 INFO L273 TraceCheckUtils]: 19: Hoare triple {1049#false} ~cond := #in~cond; {1049#false} is VALID [2018-11-23 12:09:39,168 INFO L273 TraceCheckUtils]: 20: Hoare triple {1049#false} assume 0 == ~cond; {1049#false} is VALID [2018-11-23 12:09:39,169 INFO L273 TraceCheckUtils]: 21: Hoare triple {1049#false} assume !false; {1049#false} is VALID [2018-11-23 12:09:39,170 INFO L134 CoverageAnalysis]: Checked inductivity of 18 backedges. 0 proven. 15 refuted. 0 times theorem prover too weak. 3 trivial. 0 not checked. [2018-11-23 12:09:39,170 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:39,171 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 5 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 5 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:39,180 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:09:39,234 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:09:39,234 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:39,267 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:39,268 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:39,430 INFO L256 TraceCheckUtils]: 0: Hoare triple {1048#true} call ULTIMATE.init(); {1048#true} is VALID [2018-11-23 12:09:39,430 INFO L273 TraceCheckUtils]: 1: Hoare triple {1048#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1048#true} is VALID [2018-11-23 12:09:39,430 INFO L273 TraceCheckUtils]: 2: Hoare triple {1048#true} assume true; {1048#true} is VALID [2018-11-23 12:09:39,431 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1048#true} {1048#true} #60#return; {1048#true} is VALID [2018-11-23 12:09:39,431 INFO L256 TraceCheckUtils]: 4: Hoare triple {1048#true} call #t~ret4 := main(); {1048#true} is VALID [2018-11-23 12:09:39,432 INFO L273 TraceCheckUtils]: 5: Hoare triple {1048#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {1074#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:39,432 INFO L273 TraceCheckUtils]: 6: Hoare triple {1074#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1051#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:39,433 INFO L273 TraceCheckUtils]: 7: Hoare triple {1051#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1052#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:39,436 INFO L273 TraceCheckUtils]: 8: Hoare triple {1052#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1053#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:39,447 INFO L273 TraceCheckUtils]: 9: Hoare triple {1053#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1054#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:39,452 INFO L273 TraceCheckUtils]: 10: Hoare triple {1054#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1055#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:39,452 INFO L273 TraceCheckUtils]: 11: Hoare triple {1055#(<= main_~i~0 5)} assume !(~i~0 < 100000); {1049#false} is VALID [2018-11-23 12:09:39,453 INFO L273 TraceCheckUtils]: 12: Hoare triple {1049#false} ~i~0 := 1; {1049#false} is VALID [2018-11-23 12:09:39,453 INFO L273 TraceCheckUtils]: 13: Hoare triple {1049#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1049#false} is VALID [2018-11-23 12:09:39,453 INFO L273 TraceCheckUtils]: 14: Hoare triple {1049#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1049#false} is VALID [2018-11-23 12:09:39,453 INFO L273 TraceCheckUtils]: 15: Hoare triple {1049#false} assume !(~i~0 < 100000); {1049#false} is VALID [2018-11-23 12:09:39,454 INFO L273 TraceCheckUtils]: 16: Hoare triple {1049#false} ~i~0 := 1;~j~0 := 0; {1049#false} is VALID [2018-11-23 12:09:39,454 INFO L273 TraceCheckUtils]: 17: Hoare triple {1049#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {1049#false} is VALID [2018-11-23 12:09:39,454 INFO L256 TraceCheckUtils]: 18: Hoare triple {1049#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {1049#false} is VALID [2018-11-23 12:09:39,454 INFO L273 TraceCheckUtils]: 19: Hoare triple {1049#false} ~cond := #in~cond; {1049#false} is VALID [2018-11-23 12:09:39,455 INFO L273 TraceCheckUtils]: 20: Hoare triple {1049#false} assume 0 == ~cond; {1049#false} is VALID [2018-11-23 12:09:39,455 INFO L273 TraceCheckUtils]: 21: Hoare triple {1049#false} assume !false; {1049#false} is VALID [2018-11-23 12:09:39,456 INFO L134 CoverageAnalysis]: Checked inductivity of 18 backedges. 0 proven. 15 refuted. 0 times theorem prover too weak. 3 trivial. 0 not checked. [2018-11-23 12:09:39,475 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:39,475 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [8, 8] total 9 [2018-11-23 12:09:39,475 INFO L78 Accepts]: Start accepts. Automaton has 9 states. Word has length 22 [2018-11-23 12:09:39,476 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:39,476 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 9 states. [2018-11-23 12:09:39,538 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 23 edges. 23 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:39,538 INFO L459 AbstractCegarLoop]: Interpolant automaton has 9 states [2018-11-23 12:09:39,539 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 9 interpolants. [2018-11-23 12:09:39,539 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=36, Invalid=36, Unknown=0, NotChecked=0, Total=72 [2018-11-23 12:09:39,539 INFO L87 Difference]: Start difference. First operand 26 states and 28 transitions. Second operand 9 states. [2018-11-23 12:09:39,930 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:39,931 INFO L93 Difference]: Finished difference Result 44 states and 49 transitions. [2018-11-23 12:09:39,931 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 8 states. [2018-11-23 12:09:39,931 INFO L78 Accepts]: Start accepts. Automaton has 9 states. Word has length 22 [2018-11-23 12:09:39,931 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:39,932 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 9 states. [2018-11-23 12:09:39,934 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 8 states to 8 states and 46 transitions. [2018-11-23 12:09:39,934 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 9 states. [2018-11-23 12:09:39,936 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 8 states to 8 states and 46 transitions. [2018-11-23 12:09:39,936 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 8 states and 46 transitions. [2018-11-23 12:09:39,989 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 46 edges. 46 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:39,990 INFO L225 Difference]: With dead ends: 44 [2018-11-23 12:09:39,990 INFO L226 Difference]: Without dead ends: 30 [2018-11-23 12:09:39,991 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 29 GetRequests, 22 SyntacticMatches, 0 SemanticMatches, 7 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 8 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=36, Invalid=36, Unknown=0, NotChecked=0, Total=72 [2018-11-23 12:09:39,992 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 30 states. [2018-11-23 12:09:40,022 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 30 to 27. [2018-11-23 12:09:40,022 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:40,022 INFO L82 GeneralOperation]: Start isEquivalent. First operand 30 states. Second operand 27 states. [2018-11-23 12:09:40,022 INFO L74 IsIncluded]: Start isIncluded. First operand 30 states. Second operand 27 states. [2018-11-23 12:09:40,023 INFO L87 Difference]: Start difference. First operand 30 states. Second operand 27 states. [2018-11-23 12:09:40,025 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:40,025 INFO L93 Difference]: Finished difference Result 30 states and 33 transitions. [2018-11-23 12:09:40,025 INFO L276 IsEmpty]: Start isEmpty. Operand 30 states and 33 transitions. [2018-11-23 12:09:40,026 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:40,026 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:40,026 INFO L74 IsIncluded]: Start isIncluded. First operand 27 states. Second operand 30 states. [2018-11-23 12:09:40,026 INFO L87 Difference]: Start difference. First operand 27 states. Second operand 30 states. [2018-11-23 12:09:40,028 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:40,028 INFO L93 Difference]: Finished difference Result 30 states and 33 transitions. [2018-11-23 12:09:40,029 INFO L276 IsEmpty]: Start isEmpty. Operand 30 states and 33 transitions. [2018-11-23 12:09:40,029 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:40,030 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:40,030 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:40,030 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:40,030 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 27 states. [2018-11-23 12:09:40,031 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 27 states to 27 states and 29 transitions. [2018-11-23 12:09:40,032 INFO L78 Accepts]: Start accepts. Automaton has 27 states and 29 transitions. Word has length 22 [2018-11-23 12:09:40,032 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:40,032 INFO L480 AbstractCegarLoop]: Abstraction has 27 states and 29 transitions. [2018-11-23 12:09:40,032 INFO L481 AbstractCegarLoop]: Interpolant automaton has 9 states. [2018-11-23 12:09:40,032 INFO L276 IsEmpty]: Start isEmpty. Operand 27 states and 29 transitions. [2018-11-23 12:09:40,033 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 24 [2018-11-23 12:09:40,033 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:40,033 INFO L402 BasicCegarLoop]: trace histogram [6, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:40,034 INFO L423 AbstractCegarLoop]: === Iteration 8 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:40,034 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:40,034 INFO L82 PathProgramCache]: Analyzing trace with hash -532864634, now seen corresponding path program 5 times [2018-11-23 12:09:40,034 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:40,034 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:40,035 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:40,035 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:40,035 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:40,054 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:40,200 INFO L256 TraceCheckUtils]: 0: Hoare triple {1295#true} call ULTIMATE.init(); {1295#true} is VALID [2018-11-23 12:09:40,200 INFO L273 TraceCheckUtils]: 1: Hoare triple {1295#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1295#true} is VALID [2018-11-23 12:09:40,200 INFO L273 TraceCheckUtils]: 2: Hoare triple {1295#true} assume true; {1295#true} is VALID [2018-11-23 12:09:40,201 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1295#true} {1295#true} #60#return; {1295#true} is VALID [2018-11-23 12:09:40,201 INFO L256 TraceCheckUtils]: 4: Hoare triple {1295#true} call #t~ret4 := main(); {1295#true} is VALID [2018-11-23 12:09:40,209 INFO L273 TraceCheckUtils]: 5: Hoare triple {1295#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {1297#(= main_~i~0 0)} is VALID [2018-11-23 12:09:40,210 INFO L273 TraceCheckUtils]: 6: Hoare triple {1297#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1298#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:40,211 INFO L273 TraceCheckUtils]: 7: Hoare triple {1298#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1299#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:40,211 INFO L273 TraceCheckUtils]: 8: Hoare triple {1299#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1300#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:40,212 INFO L273 TraceCheckUtils]: 9: Hoare triple {1300#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1301#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:40,213 INFO L273 TraceCheckUtils]: 10: Hoare triple {1301#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1302#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:40,214 INFO L273 TraceCheckUtils]: 11: Hoare triple {1302#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1303#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:40,215 INFO L273 TraceCheckUtils]: 12: Hoare triple {1303#(<= main_~i~0 6)} assume !(~i~0 < 100000); {1296#false} is VALID [2018-11-23 12:09:40,215 INFO L273 TraceCheckUtils]: 13: Hoare triple {1296#false} ~i~0 := 1; {1296#false} is VALID [2018-11-23 12:09:40,216 INFO L273 TraceCheckUtils]: 14: Hoare triple {1296#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1296#false} is VALID [2018-11-23 12:09:40,216 INFO L273 TraceCheckUtils]: 15: Hoare triple {1296#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1296#false} is VALID [2018-11-23 12:09:40,217 INFO L273 TraceCheckUtils]: 16: Hoare triple {1296#false} assume !(~i~0 < 100000); {1296#false} is VALID [2018-11-23 12:09:40,217 INFO L273 TraceCheckUtils]: 17: Hoare triple {1296#false} ~i~0 := 1;~j~0 := 0; {1296#false} is VALID [2018-11-23 12:09:40,217 INFO L273 TraceCheckUtils]: 18: Hoare triple {1296#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {1296#false} is VALID [2018-11-23 12:09:40,218 INFO L256 TraceCheckUtils]: 19: Hoare triple {1296#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {1296#false} is VALID [2018-11-23 12:09:40,218 INFO L273 TraceCheckUtils]: 20: Hoare triple {1296#false} ~cond := #in~cond; {1296#false} is VALID [2018-11-23 12:09:40,219 INFO L273 TraceCheckUtils]: 21: Hoare triple {1296#false} assume 0 == ~cond; {1296#false} is VALID [2018-11-23 12:09:40,219 INFO L273 TraceCheckUtils]: 22: Hoare triple {1296#false} assume !false; {1296#false} is VALID [2018-11-23 12:09:40,220 INFO L134 CoverageAnalysis]: Checked inductivity of 24 backedges. 0 proven. 21 refuted. 0 times theorem prover too weak. 3 trivial. 0 not checked. [2018-11-23 12:09:40,221 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:40,221 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 6 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 6 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:40,230 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:09:40,270 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 4 check-sat command(s) [2018-11-23 12:09:40,270 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:40,284 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:40,286 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:40,392 INFO L256 TraceCheckUtils]: 0: Hoare triple {1295#true} call ULTIMATE.init(); {1295#true} is VALID [2018-11-23 12:09:40,392 INFO L273 TraceCheckUtils]: 1: Hoare triple {1295#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1295#true} is VALID [2018-11-23 12:09:40,392 INFO L273 TraceCheckUtils]: 2: Hoare triple {1295#true} assume true; {1295#true} is VALID [2018-11-23 12:09:40,393 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1295#true} {1295#true} #60#return; {1295#true} is VALID [2018-11-23 12:09:40,393 INFO L256 TraceCheckUtils]: 4: Hoare triple {1295#true} call #t~ret4 := main(); {1295#true} is VALID [2018-11-23 12:09:40,394 INFO L273 TraceCheckUtils]: 5: Hoare triple {1295#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {1322#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:40,395 INFO L273 TraceCheckUtils]: 6: Hoare triple {1322#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1298#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:40,395 INFO L273 TraceCheckUtils]: 7: Hoare triple {1298#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1299#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:40,396 INFO L273 TraceCheckUtils]: 8: Hoare triple {1299#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1300#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:40,397 INFO L273 TraceCheckUtils]: 9: Hoare triple {1300#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1301#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:40,399 INFO L273 TraceCheckUtils]: 10: Hoare triple {1301#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1302#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:40,400 INFO L273 TraceCheckUtils]: 11: Hoare triple {1302#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1303#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:40,401 INFO L273 TraceCheckUtils]: 12: Hoare triple {1303#(<= main_~i~0 6)} assume !(~i~0 < 100000); {1296#false} is VALID [2018-11-23 12:09:40,402 INFO L273 TraceCheckUtils]: 13: Hoare triple {1296#false} ~i~0 := 1; {1296#false} is VALID [2018-11-23 12:09:40,402 INFO L273 TraceCheckUtils]: 14: Hoare triple {1296#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1296#false} is VALID [2018-11-23 12:09:40,402 INFO L273 TraceCheckUtils]: 15: Hoare triple {1296#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1296#false} is VALID [2018-11-23 12:09:40,403 INFO L273 TraceCheckUtils]: 16: Hoare triple {1296#false} assume !(~i~0 < 100000); {1296#false} is VALID [2018-11-23 12:09:40,403 INFO L273 TraceCheckUtils]: 17: Hoare triple {1296#false} ~i~0 := 1;~j~0 := 0; {1296#false} is VALID [2018-11-23 12:09:40,403 INFO L273 TraceCheckUtils]: 18: Hoare triple {1296#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {1296#false} is VALID [2018-11-23 12:09:40,404 INFO L256 TraceCheckUtils]: 19: Hoare triple {1296#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {1296#false} is VALID [2018-11-23 12:09:40,404 INFO L273 TraceCheckUtils]: 20: Hoare triple {1296#false} ~cond := #in~cond; {1296#false} is VALID [2018-11-23 12:09:40,404 INFO L273 TraceCheckUtils]: 21: Hoare triple {1296#false} assume 0 == ~cond; {1296#false} is VALID [2018-11-23 12:09:40,405 INFO L273 TraceCheckUtils]: 22: Hoare triple {1296#false} assume !false; {1296#false} is VALID [2018-11-23 12:09:40,406 INFO L134 CoverageAnalysis]: Checked inductivity of 24 backedges. 0 proven. 21 refuted. 0 times theorem prover too weak. 3 trivial. 0 not checked. [2018-11-23 12:09:40,431 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:40,431 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [9, 9] total 10 [2018-11-23 12:09:40,432 INFO L78 Accepts]: Start accepts. Automaton has 10 states. Word has length 23 [2018-11-23 12:09:40,432 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:40,432 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 10 states. [2018-11-23 12:09:40,519 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 24 edges. 24 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:40,519 INFO L459 AbstractCegarLoop]: Interpolant automaton has 10 states [2018-11-23 12:09:40,520 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 10 interpolants. [2018-11-23 12:09:40,520 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=45, Invalid=45, Unknown=0, NotChecked=0, Total=90 [2018-11-23 12:09:40,520 INFO L87 Difference]: Start difference. First operand 27 states and 29 transitions. Second operand 10 states. [2018-11-23 12:09:40,856 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:40,857 INFO L93 Difference]: Finished difference Result 45 states and 50 transitions. [2018-11-23 12:09:40,857 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 9 states. [2018-11-23 12:09:40,857 INFO L78 Accepts]: Start accepts. Automaton has 10 states. Word has length 23 [2018-11-23 12:09:40,857 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:40,857 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 10 states. [2018-11-23 12:09:40,859 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 9 states to 9 states and 47 transitions. [2018-11-23 12:09:40,860 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 10 states. [2018-11-23 12:09:40,861 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 9 states to 9 states and 47 transitions. [2018-11-23 12:09:40,861 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 9 states and 47 transitions. [2018-11-23 12:09:40,984 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 12:09:40,987 INFO L225 Difference]: With dead ends: 45 [2018-11-23 12:09:40,987 INFO L226 Difference]: Without dead ends: 31 [2018-11-23 12:09:40,988 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 31 GetRequests, 23 SyntacticMatches, 0 SemanticMatches, 8 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 10 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=45, Invalid=45, Unknown=0, NotChecked=0, Total=90 [2018-11-23 12:09:40,988 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 31 states. [2018-11-23 12:09:41,105 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 31 to 28. [2018-11-23 12:09:41,106 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:41,106 INFO L82 GeneralOperation]: Start isEquivalent. First operand 31 states. Second operand 28 states. [2018-11-23 12:09:41,106 INFO L74 IsIncluded]: Start isIncluded. First operand 31 states. Second operand 28 states. [2018-11-23 12:09:41,106 INFO L87 Difference]: Start difference. First operand 31 states. Second operand 28 states. [2018-11-23 12:09:41,109 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:41,109 INFO L93 Difference]: Finished difference Result 31 states and 34 transitions. [2018-11-23 12:09:41,109 INFO L276 IsEmpty]: Start isEmpty. Operand 31 states and 34 transitions. [2018-11-23 12:09:41,109 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:41,110 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:41,110 INFO L74 IsIncluded]: Start isIncluded. First operand 28 states. Second operand 31 states. [2018-11-23 12:09:41,110 INFO L87 Difference]: Start difference. First operand 28 states. Second operand 31 states. [2018-11-23 12:09:41,111 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:41,111 INFO L93 Difference]: Finished difference Result 31 states and 34 transitions. [2018-11-23 12:09:41,112 INFO L276 IsEmpty]: Start isEmpty. Operand 31 states and 34 transitions. [2018-11-23 12:09:41,112 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:41,112 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:41,112 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:41,113 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:41,113 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 28 states. [2018-11-23 12:09:41,114 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 28 states to 28 states and 30 transitions. [2018-11-23 12:09:41,114 INFO L78 Accepts]: Start accepts. Automaton has 28 states and 30 transitions. Word has length 23 [2018-11-23 12:09:41,114 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:41,114 INFO L480 AbstractCegarLoop]: Abstraction has 28 states and 30 transitions. [2018-11-23 12:09:41,115 INFO L481 AbstractCegarLoop]: Interpolant automaton has 10 states. [2018-11-23 12:09:41,115 INFO L276 IsEmpty]: Start isEmpty. Operand 28 states and 30 transitions. [2018-11-23 12:09:41,115 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 25 [2018-11-23 12:09:41,115 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:41,115 INFO L402 BasicCegarLoop]: trace histogram [7, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:41,116 INFO L423 AbstractCegarLoop]: === Iteration 9 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:41,116 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:41,116 INFO L82 PathProgramCache]: Analyzing trace with hash -1533202006, now seen corresponding path program 6 times [2018-11-23 12:09:41,116 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:41,116 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:41,117 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:41,117 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:41,118 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:41,136 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:41,476 INFO L256 TraceCheckUtils]: 0: Hoare triple {1552#true} call ULTIMATE.init(); {1552#true} is VALID [2018-11-23 12:09:41,477 INFO L273 TraceCheckUtils]: 1: Hoare triple {1552#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1552#true} is VALID [2018-11-23 12:09:41,478 INFO L273 TraceCheckUtils]: 2: Hoare triple {1552#true} assume true; {1552#true} is VALID [2018-11-23 12:09:41,478 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1552#true} {1552#true} #60#return; {1552#true} is VALID [2018-11-23 12:09:41,478 INFO L256 TraceCheckUtils]: 4: Hoare triple {1552#true} call #t~ret4 := main(); {1552#true} is VALID [2018-11-23 12:09:41,480 INFO L273 TraceCheckUtils]: 5: Hoare triple {1552#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {1554#(= main_~i~0 0)} is VALID [2018-11-23 12:09:41,481 INFO L273 TraceCheckUtils]: 6: Hoare triple {1554#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1555#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:41,481 INFO L273 TraceCheckUtils]: 7: Hoare triple {1555#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1556#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:41,482 INFO L273 TraceCheckUtils]: 8: Hoare triple {1556#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1557#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:41,484 INFO L273 TraceCheckUtils]: 9: Hoare triple {1557#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1558#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:41,488 INFO L273 TraceCheckUtils]: 10: Hoare triple {1558#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1559#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:41,491 INFO L273 TraceCheckUtils]: 11: Hoare triple {1559#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1560#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:41,494 INFO L273 TraceCheckUtils]: 12: Hoare triple {1560#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1561#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:41,495 INFO L273 TraceCheckUtils]: 13: Hoare triple {1561#(<= main_~i~0 7)} assume !(~i~0 < 100000); {1553#false} is VALID [2018-11-23 12:09:41,495 INFO L273 TraceCheckUtils]: 14: Hoare triple {1553#false} ~i~0 := 1; {1553#false} is VALID [2018-11-23 12:09:41,495 INFO L273 TraceCheckUtils]: 15: Hoare triple {1553#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1553#false} is VALID [2018-11-23 12:09:41,495 INFO L273 TraceCheckUtils]: 16: Hoare triple {1553#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1553#false} is VALID [2018-11-23 12:09:41,495 INFO L273 TraceCheckUtils]: 17: Hoare triple {1553#false} assume !(~i~0 < 100000); {1553#false} is VALID [2018-11-23 12:09:41,496 INFO L273 TraceCheckUtils]: 18: Hoare triple {1553#false} ~i~0 := 1;~j~0 := 0; {1553#false} is VALID [2018-11-23 12:09:41,496 INFO L273 TraceCheckUtils]: 19: Hoare triple {1553#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {1553#false} is VALID [2018-11-23 12:09:41,496 INFO L256 TraceCheckUtils]: 20: Hoare triple {1553#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {1553#false} is VALID [2018-11-23 12:09:41,496 INFO L273 TraceCheckUtils]: 21: Hoare triple {1553#false} ~cond := #in~cond; {1553#false} is VALID [2018-11-23 12:09:41,496 INFO L273 TraceCheckUtils]: 22: Hoare triple {1553#false} assume 0 == ~cond; {1553#false} is VALID [2018-11-23 12:09:41,497 INFO L273 TraceCheckUtils]: 23: Hoare triple {1553#false} assume !false; {1553#false} is VALID [2018-11-23 12:09:41,498 INFO L134 CoverageAnalysis]: Checked inductivity of 31 backedges. 0 proven. 28 refuted. 0 times theorem prover too weak. 3 trivial. 0 not checked. [2018-11-23 12:09:41,498 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:41,499 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 7 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 7 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:41,507 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE [2018-11-23 12:09:41,561 INFO L249 tOrderPrioritization]: Assert order MIX_INSIDE_OUTSIDE issued 3 check-sat command(s) [2018-11-23 12:09:41,561 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:41,574 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:41,575 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:41,675 INFO L256 TraceCheckUtils]: 0: Hoare triple {1552#true} call ULTIMATE.init(); {1552#true} is VALID [2018-11-23 12:09:41,675 INFO L273 TraceCheckUtils]: 1: Hoare triple {1552#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1552#true} is VALID [2018-11-23 12:09:41,676 INFO L273 TraceCheckUtils]: 2: Hoare triple {1552#true} assume true; {1552#true} is VALID [2018-11-23 12:09:41,676 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1552#true} {1552#true} #60#return; {1552#true} is VALID [2018-11-23 12:09:41,676 INFO L256 TraceCheckUtils]: 4: Hoare triple {1552#true} call #t~ret4 := main(); {1552#true} is VALID [2018-11-23 12:09:41,677 INFO L273 TraceCheckUtils]: 5: Hoare triple {1552#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {1552#true} is VALID [2018-11-23 12:09:41,677 INFO L273 TraceCheckUtils]: 6: Hoare triple {1552#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1552#true} is VALID [2018-11-23 12:09:41,677 INFO L273 TraceCheckUtils]: 7: Hoare triple {1552#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1552#true} is VALID [2018-11-23 12:09:41,677 INFO L273 TraceCheckUtils]: 8: Hoare triple {1552#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1552#true} is VALID [2018-11-23 12:09:41,677 INFO L273 TraceCheckUtils]: 9: Hoare triple {1552#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1552#true} is VALID [2018-11-23 12:09:41,678 INFO L273 TraceCheckUtils]: 10: Hoare triple {1552#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1552#true} is VALID [2018-11-23 12:09:41,678 INFO L273 TraceCheckUtils]: 11: Hoare triple {1552#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1552#true} is VALID [2018-11-23 12:09:41,678 INFO L273 TraceCheckUtils]: 12: Hoare triple {1552#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1552#true} is VALID [2018-11-23 12:09:41,678 INFO L273 TraceCheckUtils]: 13: Hoare triple {1552#true} assume !(~i~0 < 100000); {1552#true} is VALID [2018-11-23 12:09:41,682 INFO L273 TraceCheckUtils]: 14: Hoare triple {1552#true} ~i~0 := 1; {1555#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:41,683 INFO L273 TraceCheckUtils]: 15: Hoare triple {1555#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1610#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:41,684 INFO L273 TraceCheckUtils]: 16: Hoare triple {1610#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1614#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:41,685 INFO L273 TraceCheckUtils]: 17: Hoare triple {1614#(<= main_~i~0 19)} assume !(~i~0 < 100000); {1553#false} is VALID [2018-11-23 12:09:41,685 INFO L273 TraceCheckUtils]: 18: Hoare triple {1553#false} ~i~0 := 1;~j~0 := 0; {1553#false} is VALID [2018-11-23 12:09:41,686 INFO L273 TraceCheckUtils]: 19: Hoare triple {1553#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {1553#false} is VALID [2018-11-23 12:09:41,686 INFO L256 TraceCheckUtils]: 20: Hoare triple {1553#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {1553#false} is VALID [2018-11-23 12:09:41,686 INFO L273 TraceCheckUtils]: 21: Hoare triple {1553#false} ~cond := #in~cond; {1553#false} is VALID [2018-11-23 12:09:41,687 INFO L273 TraceCheckUtils]: 22: Hoare triple {1553#false} assume 0 == ~cond; {1553#false} is VALID [2018-11-23 12:09:41,687 INFO L273 TraceCheckUtils]: 23: Hoare triple {1553#false} assume !false; {1553#false} is VALID [2018-11-23 12:09:41,688 INFO L134 CoverageAnalysis]: Checked inductivity of 31 backedges. 0 proven. 3 refuted. 0 times theorem prover too weak. 28 trivial. 0 not checked. [2018-11-23 12:09:41,707 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:41,708 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [10, 5] total 12 [2018-11-23 12:09:41,708 INFO L78 Accepts]: Start accepts. Automaton has 12 states. Word has length 24 [2018-11-23 12:09:41,708 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:41,708 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 12 states. [2018-11-23 12:09:41,739 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 12:09:41,740 INFO L459 AbstractCegarLoop]: Interpolant automaton has 12 states [2018-11-23 12:09:41,740 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 12 interpolants. [2018-11-23 12:09:41,740 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=66, Invalid=66, Unknown=0, NotChecked=0, Total=132 [2018-11-23 12:09:41,741 INFO L87 Difference]: Start difference. First operand 28 states and 30 transitions. Second operand 12 states. [2018-11-23 12:09:42,683 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:42,684 INFO L93 Difference]: Finished difference Result 55 states and 65 transitions. [2018-11-23 12:09:42,684 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 12 states. [2018-11-23 12:09:42,684 INFO L78 Accepts]: Start accepts. Automaton has 12 states. Word has length 24 [2018-11-23 12:09:42,684 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:42,684 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 12 states. [2018-11-23 12:09:42,686 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 12 states to 12 states and 63 transitions. [2018-11-23 12:09:42,687 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 12 states. [2018-11-23 12:09:42,689 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 12 states to 12 states and 63 transitions. [2018-11-23 12:09:42,689 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 12 states and 63 transitions. [2018-11-23 12:09:42,821 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 63 edges. 63 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:42,822 INFO L225 Difference]: With dead ends: 55 [2018-11-23 12:09:42,822 INFO L226 Difference]: Without dead ends: 41 [2018-11-23 12:09:42,823 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 33 GetRequests, 23 SyntacticMatches, 0 SemanticMatches, 10 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=66, Invalid=66, Unknown=0, NotChecked=0, Total=132 [2018-11-23 12:09:42,823 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 41 states. [2018-11-23 12:09:42,882 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 41 to 32. [2018-11-23 12:09:42,882 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:42,882 INFO L82 GeneralOperation]: Start isEquivalent. First operand 41 states. Second operand 32 states. [2018-11-23 12:09:42,882 INFO L74 IsIncluded]: Start isIncluded. First operand 41 states. Second operand 32 states. [2018-11-23 12:09:42,882 INFO L87 Difference]: Start difference. First operand 41 states. Second operand 32 states. [2018-11-23 12:09:42,884 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:42,884 INFO L93 Difference]: Finished difference Result 41 states and 46 transitions. [2018-11-23 12:09:42,885 INFO L276 IsEmpty]: Start isEmpty. Operand 41 states and 46 transitions. [2018-11-23 12:09:42,885 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:42,885 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:42,885 INFO L74 IsIncluded]: Start isIncluded. First operand 32 states. Second operand 41 states. [2018-11-23 12:09:42,885 INFO L87 Difference]: Start difference. First operand 32 states. Second operand 41 states. [2018-11-23 12:09:42,887 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:42,887 INFO L93 Difference]: Finished difference Result 41 states and 46 transitions. [2018-11-23 12:09:42,888 INFO L276 IsEmpty]: Start isEmpty. Operand 41 states and 46 transitions. [2018-11-23 12:09:42,888 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:42,888 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:42,888 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:42,888 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:42,889 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 32 states. [2018-11-23 12:09:42,890 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 32 states to 32 states and 34 transitions. [2018-11-23 12:09:42,890 INFO L78 Accepts]: Start accepts. Automaton has 32 states and 34 transitions. Word has length 24 [2018-11-23 12:09:42,890 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:42,890 INFO L480 AbstractCegarLoop]: Abstraction has 32 states and 34 transitions. [2018-11-23 12:09:42,890 INFO L481 AbstractCegarLoop]: Interpolant automaton has 12 states. [2018-11-23 12:09:42,890 INFO L276 IsEmpty]: Start isEmpty. Operand 32 states and 34 transitions. [2018-11-23 12:09:42,891 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 29 [2018-11-23 12:09:42,891 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:42,891 INFO L402 BasicCegarLoop]: trace histogram [10, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:42,891 INFO L423 AbstractCegarLoop]: === Iteration 10 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:42,892 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:42,892 INFO L82 PathProgramCache]: Analyzing trace with hash 2083735689, now seen corresponding path program 7 times [2018-11-23 12:09:42,892 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:42,892 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:42,893 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:42,893 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:42,893 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:42,917 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:43,227 INFO L256 TraceCheckUtils]: 0: Hoare triple {1860#true} call ULTIMATE.init(); {1860#true} is VALID [2018-11-23 12:09:43,228 INFO L273 TraceCheckUtils]: 1: Hoare triple {1860#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1860#true} is VALID [2018-11-23 12:09:43,228 INFO L273 TraceCheckUtils]: 2: Hoare triple {1860#true} assume true; {1860#true} is VALID [2018-11-23 12:09:43,228 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1860#true} {1860#true} #60#return; {1860#true} is VALID [2018-11-23 12:09:43,229 INFO L256 TraceCheckUtils]: 4: Hoare triple {1860#true} call #t~ret4 := main(); {1860#true} is VALID [2018-11-23 12:09:43,229 INFO L273 TraceCheckUtils]: 5: Hoare triple {1860#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {1862#(= main_~i~0 0)} is VALID [2018-11-23 12:09:43,230 INFO L273 TraceCheckUtils]: 6: Hoare triple {1862#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1863#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:43,231 INFO L273 TraceCheckUtils]: 7: Hoare triple {1863#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1864#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:43,231 INFO L273 TraceCheckUtils]: 8: Hoare triple {1864#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1865#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:43,232 INFO L273 TraceCheckUtils]: 9: Hoare triple {1865#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1866#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:43,233 INFO L273 TraceCheckUtils]: 10: Hoare triple {1866#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1867#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:43,234 INFO L273 TraceCheckUtils]: 11: Hoare triple {1867#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1868#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:43,236 INFO L273 TraceCheckUtils]: 12: Hoare triple {1868#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1869#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:43,237 INFO L273 TraceCheckUtils]: 13: Hoare triple {1869#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1870#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:43,238 INFO L273 TraceCheckUtils]: 14: Hoare triple {1870#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1871#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:43,240 INFO L273 TraceCheckUtils]: 15: Hoare triple {1871#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1872#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:43,241 INFO L273 TraceCheckUtils]: 16: Hoare triple {1872#(<= main_~i~0 10)} assume !(~i~0 < 100000); {1861#false} is VALID [2018-11-23 12:09:43,241 INFO L273 TraceCheckUtils]: 17: Hoare triple {1861#false} ~i~0 := 1; {1861#false} is VALID [2018-11-23 12:09:43,242 INFO L273 TraceCheckUtils]: 18: Hoare triple {1861#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1861#false} is VALID [2018-11-23 12:09:43,242 INFO L273 TraceCheckUtils]: 19: Hoare triple {1861#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1861#false} is VALID [2018-11-23 12:09:43,243 INFO L273 TraceCheckUtils]: 20: Hoare triple {1861#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1861#false} is VALID [2018-11-23 12:09:43,243 INFO L273 TraceCheckUtils]: 21: Hoare triple {1861#false} assume !(~i~0 < 100000); {1861#false} is VALID [2018-11-23 12:09:43,243 INFO L273 TraceCheckUtils]: 22: Hoare triple {1861#false} ~i~0 := 1;~j~0 := 0; {1861#false} is VALID [2018-11-23 12:09:43,244 INFO L273 TraceCheckUtils]: 23: Hoare triple {1861#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {1861#false} is VALID [2018-11-23 12:09:43,244 INFO L256 TraceCheckUtils]: 24: Hoare triple {1861#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {1861#false} is VALID [2018-11-23 12:09:43,244 INFO L273 TraceCheckUtils]: 25: Hoare triple {1861#false} ~cond := #in~cond; {1861#false} is VALID [2018-11-23 12:09:43,244 INFO L273 TraceCheckUtils]: 26: Hoare triple {1861#false} assume 0 == ~cond; {1861#false} is VALID [2018-11-23 12:09:43,244 INFO L273 TraceCheckUtils]: 27: Hoare triple {1861#false} assume !false; {1861#false} is VALID [2018-11-23 12:09:43,245 INFO L134 CoverageAnalysis]: Checked inductivity of 61 backedges. 0 proven. 55 refuted. 0 times theorem prover too weak. 6 trivial. 0 not checked. [2018-11-23 12:09:43,248 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:43,248 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 8 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 8 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:43,265 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:43,296 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:43,321 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:43,322 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:43,462 INFO L256 TraceCheckUtils]: 0: Hoare triple {1860#true} call ULTIMATE.init(); {1860#true} is VALID [2018-11-23 12:09:43,462 INFO L273 TraceCheckUtils]: 1: Hoare triple {1860#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1860#true} is VALID [2018-11-23 12:09:43,463 INFO L273 TraceCheckUtils]: 2: Hoare triple {1860#true} assume true; {1860#true} is VALID [2018-11-23 12:09:43,463 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1860#true} {1860#true} #60#return; {1860#true} is VALID [2018-11-23 12:09:43,463 INFO L256 TraceCheckUtils]: 4: Hoare triple {1860#true} call #t~ret4 := main(); {1860#true} is VALID [2018-11-23 12:09:43,464 INFO L273 TraceCheckUtils]: 5: Hoare triple {1860#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {1891#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:43,464 INFO L273 TraceCheckUtils]: 6: Hoare triple {1891#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1863#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:43,465 INFO L273 TraceCheckUtils]: 7: Hoare triple {1863#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1864#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:43,466 INFO L273 TraceCheckUtils]: 8: Hoare triple {1864#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1865#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:43,467 INFO L273 TraceCheckUtils]: 9: Hoare triple {1865#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1866#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:43,468 INFO L273 TraceCheckUtils]: 10: Hoare triple {1866#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1867#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:43,469 INFO L273 TraceCheckUtils]: 11: Hoare triple {1867#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1868#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:43,471 INFO L273 TraceCheckUtils]: 12: Hoare triple {1868#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1869#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:43,472 INFO L273 TraceCheckUtils]: 13: Hoare triple {1869#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1870#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:43,473 INFO L273 TraceCheckUtils]: 14: Hoare triple {1870#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1871#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:43,474 INFO L273 TraceCheckUtils]: 15: Hoare triple {1871#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {1872#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:43,474 INFO L273 TraceCheckUtils]: 16: Hoare triple {1872#(<= main_~i~0 10)} assume !(~i~0 < 100000); {1861#false} is VALID [2018-11-23 12:09:43,475 INFO L273 TraceCheckUtils]: 17: Hoare triple {1861#false} ~i~0 := 1; {1861#false} is VALID [2018-11-23 12:09:43,475 INFO L273 TraceCheckUtils]: 18: Hoare triple {1861#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1861#false} is VALID [2018-11-23 12:09:43,475 INFO L273 TraceCheckUtils]: 19: Hoare triple {1861#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1861#false} is VALID [2018-11-23 12:09:43,476 INFO L273 TraceCheckUtils]: 20: Hoare triple {1861#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {1861#false} is VALID [2018-11-23 12:09:43,476 INFO L273 TraceCheckUtils]: 21: Hoare triple {1861#false} assume !(~i~0 < 100000); {1861#false} is VALID [2018-11-23 12:09:43,476 INFO L273 TraceCheckUtils]: 22: Hoare triple {1861#false} ~i~0 := 1;~j~0 := 0; {1861#false} is VALID [2018-11-23 12:09:43,476 INFO L273 TraceCheckUtils]: 23: Hoare triple {1861#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {1861#false} is VALID [2018-11-23 12:09:43,477 INFO L256 TraceCheckUtils]: 24: Hoare triple {1861#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {1861#false} is VALID [2018-11-23 12:09:43,477 INFO L273 TraceCheckUtils]: 25: Hoare triple {1861#false} ~cond := #in~cond; {1861#false} is VALID [2018-11-23 12:09:43,477 INFO L273 TraceCheckUtils]: 26: Hoare triple {1861#false} assume 0 == ~cond; {1861#false} is VALID [2018-11-23 12:09:43,478 INFO L273 TraceCheckUtils]: 27: Hoare triple {1861#false} assume !false; {1861#false} is VALID [2018-11-23 12:09:43,479 INFO L134 CoverageAnalysis]: Checked inductivity of 61 backedges. 0 proven. 55 refuted. 0 times theorem prover too weak. 6 trivial. 0 not checked. [2018-11-23 12:09:43,501 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:43,501 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [13, 13] total 14 [2018-11-23 12:09:43,502 INFO L78 Accepts]: Start accepts. Automaton has 14 states. Word has length 28 [2018-11-23 12:09:43,502 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:43,502 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 14 states. [2018-11-23 12:09:43,545 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 28 edges. 28 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:43,545 INFO L459 AbstractCegarLoop]: Interpolant automaton has 14 states [2018-11-23 12:09:43,546 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 14 interpolants. [2018-11-23 12:09:43,546 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=91, Invalid=91, Unknown=0, NotChecked=0, Total=182 [2018-11-23 12:09:43,546 INFO L87 Difference]: Start difference. First operand 32 states and 34 transitions. Second operand 14 states. [2018-11-23 12:09:43,825 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:43,825 INFO L93 Difference]: Finished difference Result 54 states and 60 transitions. [2018-11-23 12:09:43,825 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 13 states. [2018-11-23 12:09:43,825 INFO L78 Accepts]: Start accepts. Automaton has 14 states. Word has length 28 [2018-11-23 12:09:43,825 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:43,826 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 14 states. [2018-11-23 12:09:43,828 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 13 states to 13 states and 56 transitions. [2018-11-23 12:09:43,828 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 14 states. [2018-11-23 12:09:43,829 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 13 states to 13 states and 56 transitions. [2018-11-23 12:09:43,830 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 13 states and 56 transitions. [2018-11-23 12:09:43,885 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 56 edges. 56 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:43,887 INFO L225 Difference]: With dead ends: 54 [2018-11-23 12:09:43,887 INFO L226 Difference]: Without dead ends: 39 [2018-11-23 12:09:43,888 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 40 GetRequests, 28 SyntacticMatches, 0 SemanticMatches, 12 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 18 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=91, Invalid=91, Unknown=0, NotChecked=0, Total=182 [2018-11-23 12:09:43,888 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 39 states. [2018-11-23 12:09:43,909 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 39 to 33. [2018-11-23 12:09:43,909 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:43,909 INFO L82 GeneralOperation]: Start isEquivalent. First operand 39 states. Second operand 33 states. [2018-11-23 12:09:43,910 INFO L74 IsIncluded]: Start isIncluded. First operand 39 states. Second operand 33 states. [2018-11-23 12:09:43,910 INFO L87 Difference]: Start difference. First operand 39 states. Second operand 33 states. [2018-11-23 12:09:43,912 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:43,912 INFO L93 Difference]: Finished difference Result 39 states and 43 transitions. [2018-11-23 12:09:43,912 INFO L276 IsEmpty]: Start isEmpty. Operand 39 states and 43 transitions. [2018-11-23 12:09:43,913 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:43,913 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:43,913 INFO L74 IsIncluded]: Start isIncluded. First operand 33 states. Second operand 39 states. [2018-11-23 12:09:43,913 INFO L87 Difference]: Start difference. First operand 33 states. Second operand 39 states. [2018-11-23 12:09:43,915 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:43,915 INFO L93 Difference]: Finished difference Result 39 states and 43 transitions. [2018-11-23 12:09:43,915 INFO L276 IsEmpty]: Start isEmpty. Operand 39 states and 43 transitions. [2018-11-23 12:09:43,916 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:43,916 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:43,916 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:43,916 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:43,916 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 33 states. [2018-11-23 12:09:43,917 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 33 states to 33 states and 35 transitions. [2018-11-23 12:09:43,917 INFO L78 Accepts]: Start accepts. Automaton has 33 states and 35 transitions. Word has length 28 [2018-11-23 12:09:43,918 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:43,918 INFO L480 AbstractCegarLoop]: Abstraction has 33 states and 35 transitions. [2018-11-23 12:09:43,918 INFO L481 AbstractCegarLoop]: Interpolant automaton has 14 states. [2018-11-23 12:09:43,918 INFO L276 IsEmpty]: Start isEmpty. Operand 33 states and 35 transitions. [2018-11-23 12:09:43,918 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 30 [2018-11-23 12:09:43,919 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:43,919 INFO L402 BasicCegarLoop]: trace histogram [11, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:43,919 INFO L423 AbstractCegarLoop]: === Iteration 11 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:43,919 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:43,919 INFO L82 PathProgramCache]: Analyzing trace with hash -20205851, now seen corresponding path program 8 times [2018-11-23 12:09:43,919 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:43,920 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:43,920 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:43,921 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:43,921 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:43,941 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:44,447 INFO L256 TraceCheckUtils]: 0: Hoare triple {2179#true} call ULTIMATE.init(); {2179#true} is VALID [2018-11-23 12:09:44,447 INFO L273 TraceCheckUtils]: 1: Hoare triple {2179#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {2179#true} is VALID [2018-11-23 12:09:44,448 INFO L273 TraceCheckUtils]: 2: Hoare triple {2179#true} assume true; {2179#true} is VALID [2018-11-23 12:09:44,448 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2179#true} {2179#true} #60#return; {2179#true} is VALID [2018-11-23 12:09:44,448 INFO L256 TraceCheckUtils]: 4: Hoare triple {2179#true} call #t~ret4 := main(); {2179#true} is VALID [2018-11-23 12:09:44,448 INFO L273 TraceCheckUtils]: 5: Hoare triple {2179#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {2181#(= main_~i~0 0)} is VALID [2018-11-23 12:09:44,449 INFO L273 TraceCheckUtils]: 6: Hoare triple {2181#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2182#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:44,450 INFO L273 TraceCheckUtils]: 7: Hoare triple {2182#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2183#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:44,451 INFO L273 TraceCheckUtils]: 8: Hoare triple {2183#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2184#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:44,451 INFO L273 TraceCheckUtils]: 9: Hoare triple {2184#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2185#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:44,452 INFO L273 TraceCheckUtils]: 10: Hoare triple {2185#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2186#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:44,453 INFO L273 TraceCheckUtils]: 11: Hoare triple {2186#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2187#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:44,454 INFO L273 TraceCheckUtils]: 12: Hoare triple {2187#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2188#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:44,455 INFO L273 TraceCheckUtils]: 13: Hoare triple {2188#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2189#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:44,463 INFO L273 TraceCheckUtils]: 14: Hoare triple {2189#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2190#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:44,463 INFO L273 TraceCheckUtils]: 15: Hoare triple {2190#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2191#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:44,464 INFO L273 TraceCheckUtils]: 16: Hoare triple {2191#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2192#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:44,465 INFO L273 TraceCheckUtils]: 17: Hoare triple {2192#(<= main_~i~0 11)} assume !(~i~0 < 100000); {2180#false} is VALID [2018-11-23 12:09:44,465 INFO L273 TraceCheckUtils]: 18: Hoare triple {2180#false} ~i~0 := 1; {2180#false} is VALID [2018-11-23 12:09:44,465 INFO L273 TraceCheckUtils]: 19: Hoare triple {2180#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2180#false} is VALID [2018-11-23 12:09:44,465 INFO L273 TraceCheckUtils]: 20: Hoare triple {2180#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2180#false} is VALID [2018-11-23 12:09:44,465 INFO L273 TraceCheckUtils]: 21: Hoare triple {2180#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2180#false} is VALID [2018-11-23 12:09:44,465 INFO L273 TraceCheckUtils]: 22: Hoare triple {2180#false} assume !(~i~0 < 100000); {2180#false} is VALID [2018-11-23 12:09:44,465 INFO L273 TraceCheckUtils]: 23: Hoare triple {2180#false} ~i~0 := 1;~j~0 := 0; {2180#false} is VALID [2018-11-23 12:09:44,466 INFO L273 TraceCheckUtils]: 24: Hoare triple {2180#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {2180#false} is VALID [2018-11-23 12:09:44,466 INFO L256 TraceCheckUtils]: 25: Hoare triple {2180#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {2180#false} is VALID [2018-11-23 12:09:44,466 INFO L273 TraceCheckUtils]: 26: Hoare triple {2180#false} ~cond := #in~cond; {2180#false} is VALID [2018-11-23 12:09:44,466 INFO L273 TraceCheckUtils]: 27: Hoare triple {2180#false} assume 0 == ~cond; {2180#false} is VALID [2018-11-23 12:09:44,466 INFO L273 TraceCheckUtils]: 28: Hoare triple {2180#false} assume !false; {2180#false} is VALID [2018-11-23 12:09:44,469 INFO L134 CoverageAnalysis]: Checked inductivity of 72 backedges. 0 proven. 66 refuted. 0 times theorem prover too weak. 6 trivial. 0 not checked. [2018-11-23 12:09:44,471 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:44,471 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 9 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 9 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:44,484 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:09:44,510 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:09:44,510 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:44,527 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:44,529 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:44,632 INFO L256 TraceCheckUtils]: 0: Hoare triple {2179#true} call ULTIMATE.init(); {2179#true} is VALID [2018-11-23 12:09:44,633 INFO L273 TraceCheckUtils]: 1: Hoare triple {2179#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {2179#true} is VALID [2018-11-23 12:09:44,633 INFO L273 TraceCheckUtils]: 2: Hoare triple {2179#true} assume true; {2179#true} is VALID [2018-11-23 12:09:44,633 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2179#true} {2179#true} #60#return; {2179#true} is VALID [2018-11-23 12:09:44,634 INFO L256 TraceCheckUtils]: 4: Hoare triple {2179#true} call #t~ret4 := main(); {2179#true} is VALID [2018-11-23 12:09:44,635 INFO L273 TraceCheckUtils]: 5: Hoare triple {2179#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {2211#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:44,635 INFO L273 TraceCheckUtils]: 6: Hoare triple {2211#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2182#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:44,639 INFO L273 TraceCheckUtils]: 7: Hoare triple {2182#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2183#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:44,640 INFO L273 TraceCheckUtils]: 8: Hoare triple {2183#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2184#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:44,640 INFO L273 TraceCheckUtils]: 9: Hoare triple {2184#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2185#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:44,641 INFO L273 TraceCheckUtils]: 10: Hoare triple {2185#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2186#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:44,641 INFO L273 TraceCheckUtils]: 11: Hoare triple {2186#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2187#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:44,642 INFO L273 TraceCheckUtils]: 12: Hoare triple {2187#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2188#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:44,643 INFO L273 TraceCheckUtils]: 13: Hoare triple {2188#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2189#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:44,643 INFO L273 TraceCheckUtils]: 14: Hoare triple {2189#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2190#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:44,644 INFO L273 TraceCheckUtils]: 15: Hoare triple {2190#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2191#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:44,646 INFO L273 TraceCheckUtils]: 16: Hoare triple {2191#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2192#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:44,646 INFO L273 TraceCheckUtils]: 17: Hoare triple {2192#(<= main_~i~0 11)} assume !(~i~0 < 100000); {2180#false} is VALID [2018-11-23 12:09:44,647 INFO L273 TraceCheckUtils]: 18: Hoare triple {2180#false} ~i~0 := 1; {2180#false} is VALID [2018-11-23 12:09:44,647 INFO L273 TraceCheckUtils]: 19: Hoare triple {2180#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2180#false} is VALID [2018-11-23 12:09:44,647 INFO L273 TraceCheckUtils]: 20: Hoare triple {2180#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2180#false} is VALID [2018-11-23 12:09:44,647 INFO L273 TraceCheckUtils]: 21: Hoare triple {2180#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2180#false} is VALID [2018-11-23 12:09:44,647 INFO L273 TraceCheckUtils]: 22: Hoare triple {2180#false} assume !(~i~0 < 100000); {2180#false} is VALID [2018-11-23 12:09:44,648 INFO L273 TraceCheckUtils]: 23: Hoare triple {2180#false} ~i~0 := 1;~j~0 := 0; {2180#false} is VALID [2018-11-23 12:09:44,648 INFO L273 TraceCheckUtils]: 24: Hoare triple {2180#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {2180#false} is VALID [2018-11-23 12:09:44,648 INFO L256 TraceCheckUtils]: 25: Hoare triple {2180#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {2180#false} is VALID [2018-11-23 12:09:44,648 INFO L273 TraceCheckUtils]: 26: Hoare triple {2180#false} ~cond := #in~cond; {2180#false} is VALID [2018-11-23 12:09:44,649 INFO L273 TraceCheckUtils]: 27: Hoare triple {2180#false} assume 0 == ~cond; {2180#false} is VALID [2018-11-23 12:09:44,649 INFO L273 TraceCheckUtils]: 28: Hoare triple {2180#false} assume !false; {2180#false} is VALID [2018-11-23 12:09:44,650 INFO L134 CoverageAnalysis]: Checked inductivity of 72 backedges. 0 proven. 66 refuted. 0 times theorem prover too weak. 6 trivial. 0 not checked. [2018-11-23 12:09:44,669 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:44,670 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [14, 14] total 15 [2018-11-23 12:09:44,670 INFO L78 Accepts]: Start accepts. Automaton has 15 states. Word has length 29 [2018-11-23 12:09:44,670 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:44,670 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 15 states. [2018-11-23 12:09:44,695 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 29 edges. 29 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:44,695 INFO L459 AbstractCegarLoop]: Interpolant automaton has 15 states [2018-11-23 12:09:44,696 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 15 interpolants. [2018-11-23 12:09:44,696 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=105, Invalid=105, Unknown=0, NotChecked=0, Total=210 [2018-11-23 12:09:44,696 INFO L87 Difference]: Start difference. First operand 33 states and 35 transitions. Second operand 15 states. [2018-11-23 12:09:45,571 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:45,571 INFO L93 Difference]: Finished difference Result 55 states and 61 transitions. [2018-11-23 12:09:45,572 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 14 states. [2018-11-23 12:09:45,572 INFO L78 Accepts]: Start accepts. Automaton has 15 states. Word has length 29 [2018-11-23 12:09:45,572 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:45,572 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 15 states. [2018-11-23 12:09:45,574 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 14 states to 14 states and 57 transitions. [2018-11-23 12:09:45,574 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 15 states. [2018-11-23 12:09:45,576 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 14 states to 14 states and 57 transitions. [2018-11-23 12:09:45,576 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 14 states and 57 transitions. [2018-11-23 12:09:45,665 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 57 edges. 57 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:45,666 INFO L225 Difference]: With dead ends: 55 [2018-11-23 12:09:45,666 INFO L226 Difference]: Without dead ends: 40 [2018-11-23 12:09:45,667 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 42 GetRequests, 29 SyntacticMatches, 0 SemanticMatches, 13 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 20 ImplicationChecksByTransitivity, 0.3s TimeCoverageRelationStatistics Valid=105, Invalid=105, Unknown=0, NotChecked=0, Total=210 [2018-11-23 12:09:45,667 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 40 states. [2018-11-23 12:09:45,687 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 40 to 34. [2018-11-23 12:09:45,687 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:45,687 INFO L82 GeneralOperation]: Start isEquivalent. First operand 40 states. Second operand 34 states. [2018-11-23 12:09:45,687 INFO L74 IsIncluded]: Start isIncluded. First operand 40 states. Second operand 34 states. [2018-11-23 12:09:45,687 INFO L87 Difference]: Start difference. First operand 40 states. Second operand 34 states. [2018-11-23 12:09:45,689 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:45,689 INFO L93 Difference]: Finished difference Result 40 states and 44 transitions. [2018-11-23 12:09:45,689 INFO L276 IsEmpty]: Start isEmpty. Operand 40 states and 44 transitions. [2018-11-23 12:09:45,689 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:45,690 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:45,690 INFO L74 IsIncluded]: Start isIncluded. First operand 34 states. Second operand 40 states. [2018-11-23 12:09:45,690 INFO L87 Difference]: Start difference. First operand 34 states. Second operand 40 states. [2018-11-23 12:09:45,692 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:45,692 INFO L93 Difference]: Finished difference Result 40 states and 44 transitions. [2018-11-23 12:09:45,692 INFO L276 IsEmpty]: Start isEmpty. Operand 40 states and 44 transitions. [2018-11-23 12:09:45,692 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:45,693 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:45,693 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:45,693 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:45,693 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 34 states. [2018-11-23 12:09:45,694 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 34 states to 34 states and 36 transitions. [2018-11-23 12:09:45,694 INFO L78 Accepts]: Start accepts. Automaton has 34 states and 36 transitions. Word has length 29 [2018-11-23 12:09:45,694 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:45,694 INFO L480 AbstractCegarLoop]: Abstraction has 34 states and 36 transitions. [2018-11-23 12:09:45,694 INFO L481 AbstractCegarLoop]: Interpolant automaton has 15 states. [2018-11-23 12:09:45,695 INFO L276 IsEmpty]: Start isEmpty. Operand 34 states and 36 transitions. [2018-11-23 12:09:45,695 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 31 [2018-11-23 12:09:45,695 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:45,695 INFO L402 BasicCegarLoop]: trace histogram [12, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:45,696 INFO L423 AbstractCegarLoop]: === Iteration 12 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:45,696 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:45,696 INFO L82 PathProgramCache]: Analyzing trace with hash -817884151, now seen corresponding path program 9 times [2018-11-23 12:09:45,696 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:45,696 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:45,697 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:45,697 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:45,697 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:45,734 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:45,945 INFO L256 TraceCheckUtils]: 0: Hoare triple {2508#true} call ULTIMATE.init(); {2508#true} is VALID [2018-11-23 12:09:45,946 INFO L273 TraceCheckUtils]: 1: Hoare triple {2508#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {2508#true} is VALID [2018-11-23 12:09:45,946 INFO L273 TraceCheckUtils]: 2: Hoare triple {2508#true} assume true; {2508#true} is VALID [2018-11-23 12:09:45,946 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2508#true} {2508#true} #60#return; {2508#true} is VALID [2018-11-23 12:09:45,947 INFO L256 TraceCheckUtils]: 4: Hoare triple {2508#true} call #t~ret4 := main(); {2508#true} is VALID [2018-11-23 12:09:45,951 INFO L273 TraceCheckUtils]: 5: Hoare triple {2508#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {2510#(= main_~i~0 0)} is VALID [2018-11-23 12:09:45,952 INFO L273 TraceCheckUtils]: 6: Hoare triple {2510#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2511#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:45,953 INFO L273 TraceCheckUtils]: 7: Hoare triple {2511#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2512#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:45,954 INFO L273 TraceCheckUtils]: 8: Hoare triple {2512#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2513#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:45,955 INFO L273 TraceCheckUtils]: 9: Hoare triple {2513#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2514#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:45,956 INFO L273 TraceCheckUtils]: 10: Hoare triple {2514#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2515#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:45,957 INFO L273 TraceCheckUtils]: 11: Hoare triple {2515#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2516#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:45,958 INFO L273 TraceCheckUtils]: 12: Hoare triple {2516#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2517#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:45,959 INFO L273 TraceCheckUtils]: 13: Hoare triple {2517#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2518#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:45,960 INFO L273 TraceCheckUtils]: 14: Hoare triple {2518#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2519#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:45,961 INFO L273 TraceCheckUtils]: 15: Hoare triple {2519#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2520#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:45,962 INFO L273 TraceCheckUtils]: 16: Hoare triple {2520#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2521#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:45,963 INFO L273 TraceCheckUtils]: 17: Hoare triple {2521#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2522#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:45,964 INFO L273 TraceCheckUtils]: 18: Hoare triple {2522#(<= main_~i~0 12)} assume !(~i~0 < 100000); {2509#false} is VALID [2018-11-23 12:09:45,964 INFO L273 TraceCheckUtils]: 19: Hoare triple {2509#false} ~i~0 := 1; {2509#false} is VALID [2018-11-23 12:09:45,964 INFO L273 TraceCheckUtils]: 20: Hoare triple {2509#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2509#false} is VALID [2018-11-23 12:09:45,964 INFO L273 TraceCheckUtils]: 21: Hoare triple {2509#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2509#false} is VALID [2018-11-23 12:09:45,965 INFO L273 TraceCheckUtils]: 22: Hoare triple {2509#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2509#false} is VALID [2018-11-23 12:09:45,965 INFO L273 TraceCheckUtils]: 23: Hoare triple {2509#false} assume !(~i~0 < 100000); {2509#false} is VALID [2018-11-23 12:09:45,965 INFO L273 TraceCheckUtils]: 24: Hoare triple {2509#false} ~i~0 := 1;~j~0 := 0; {2509#false} is VALID [2018-11-23 12:09:45,965 INFO L273 TraceCheckUtils]: 25: Hoare triple {2509#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {2509#false} is VALID [2018-11-23 12:09:45,965 INFO L256 TraceCheckUtils]: 26: Hoare triple {2509#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {2509#false} is VALID [2018-11-23 12:09:45,966 INFO L273 TraceCheckUtils]: 27: Hoare triple {2509#false} ~cond := #in~cond; {2509#false} is VALID [2018-11-23 12:09:45,966 INFO L273 TraceCheckUtils]: 28: Hoare triple {2509#false} assume 0 == ~cond; {2509#false} is VALID [2018-11-23 12:09:45,966 INFO L273 TraceCheckUtils]: 29: Hoare triple {2509#false} assume !false; {2509#false} is VALID [2018-11-23 12:09:45,967 INFO L134 CoverageAnalysis]: Checked inductivity of 84 backedges. 0 proven. 78 refuted. 0 times theorem prover too weak. 6 trivial. 0 not checked. [2018-11-23 12:09:45,968 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:45,968 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 10 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 10 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:45,977 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:09:46,041 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 3 check-sat command(s) [2018-11-23 12:09:46,041 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:46,065 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:46,067 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:46,323 INFO L256 TraceCheckUtils]: 0: Hoare triple {2508#true} call ULTIMATE.init(); {2508#true} is VALID [2018-11-23 12:09:46,324 INFO L273 TraceCheckUtils]: 1: Hoare triple {2508#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {2508#true} is VALID [2018-11-23 12:09:46,324 INFO L273 TraceCheckUtils]: 2: Hoare triple {2508#true} assume true; {2508#true} is VALID [2018-11-23 12:09:46,324 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2508#true} {2508#true} #60#return; {2508#true} is VALID [2018-11-23 12:09:46,324 INFO L256 TraceCheckUtils]: 4: Hoare triple {2508#true} call #t~ret4 := main(); {2508#true} is VALID [2018-11-23 12:09:46,325 INFO L273 TraceCheckUtils]: 5: Hoare triple {2508#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {2508#true} is VALID [2018-11-23 12:09:46,325 INFO L273 TraceCheckUtils]: 6: Hoare triple {2508#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2508#true} is VALID [2018-11-23 12:09:46,325 INFO L273 TraceCheckUtils]: 7: Hoare triple {2508#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2508#true} is VALID [2018-11-23 12:09:46,325 INFO L273 TraceCheckUtils]: 8: Hoare triple {2508#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2508#true} is VALID [2018-11-23 12:09:46,326 INFO L273 TraceCheckUtils]: 9: Hoare triple {2508#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2508#true} is VALID [2018-11-23 12:09:46,326 INFO L273 TraceCheckUtils]: 10: Hoare triple {2508#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2508#true} is VALID [2018-11-23 12:09:46,326 INFO L273 TraceCheckUtils]: 11: Hoare triple {2508#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2508#true} is VALID [2018-11-23 12:09:46,326 INFO L273 TraceCheckUtils]: 12: Hoare triple {2508#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2508#true} is VALID [2018-11-23 12:09:46,326 INFO L273 TraceCheckUtils]: 13: Hoare triple {2508#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2508#true} is VALID [2018-11-23 12:09:46,327 INFO L273 TraceCheckUtils]: 14: Hoare triple {2508#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2508#true} is VALID [2018-11-23 12:09:46,327 INFO L273 TraceCheckUtils]: 15: Hoare triple {2508#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2508#true} is VALID [2018-11-23 12:09:46,327 INFO L273 TraceCheckUtils]: 16: Hoare triple {2508#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2508#true} is VALID [2018-11-23 12:09:46,327 INFO L273 TraceCheckUtils]: 17: Hoare triple {2508#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2508#true} is VALID [2018-11-23 12:09:46,327 INFO L273 TraceCheckUtils]: 18: Hoare triple {2508#true} assume !(~i~0 < 100000); {2508#true} is VALID [2018-11-23 12:09:46,327 INFO L273 TraceCheckUtils]: 19: Hoare triple {2508#true} ~i~0 := 1; {2511#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:46,328 INFO L273 TraceCheckUtils]: 20: Hoare triple {2511#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2520#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:46,329 INFO L273 TraceCheckUtils]: 21: Hoare triple {2520#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2589#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:46,329 INFO L273 TraceCheckUtils]: 22: Hoare triple {2589#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2593#(<= main_~i~0 28)} is VALID [2018-11-23 12:09:46,330 INFO L273 TraceCheckUtils]: 23: Hoare triple {2593#(<= main_~i~0 28)} assume !(~i~0 < 100000); {2509#false} is VALID [2018-11-23 12:09:46,330 INFO L273 TraceCheckUtils]: 24: Hoare triple {2509#false} ~i~0 := 1;~j~0 := 0; {2509#false} is VALID [2018-11-23 12:09:46,330 INFO L273 TraceCheckUtils]: 25: Hoare triple {2509#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {2509#false} is VALID [2018-11-23 12:09:46,330 INFO L256 TraceCheckUtils]: 26: Hoare triple {2509#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {2509#false} is VALID [2018-11-23 12:09:46,330 INFO L273 TraceCheckUtils]: 27: Hoare triple {2509#false} ~cond := #in~cond; {2509#false} is VALID [2018-11-23 12:09:46,331 INFO L273 TraceCheckUtils]: 28: Hoare triple {2509#false} assume 0 == ~cond; {2509#false} is VALID [2018-11-23 12:09:46,331 INFO L273 TraceCheckUtils]: 29: Hoare triple {2509#false} assume !false; {2509#false} is VALID [2018-11-23 12:09:46,331 INFO L134 CoverageAnalysis]: Checked inductivity of 84 backedges. 0 proven. 6 refuted. 0 times theorem prover too weak. 78 trivial. 0 not checked. [2018-11-23 12:09:46,351 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:46,352 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [15, 6] total 17 [2018-11-23 12:09:46,352 INFO L78 Accepts]: Start accepts. Automaton has 17 states. Word has length 30 [2018-11-23 12:09:46,352 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:46,352 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 17 states. [2018-11-23 12:09:46,408 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 36 edges. 36 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:46,408 INFO L459 AbstractCegarLoop]: Interpolant automaton has 17 states [2018-11-23 12:09:46,409 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 17 interpolants. [2018-11-23 12:09:46,409 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=136, Invalid=136, Unknown=0, NotChecked=0, Total=272 [2018-11-23 12:09:46,409 INFO L87 Difference]: Start difference. First operand 34 states and 36 transitions. Second operand 17 states. [2018-11-23 12:09:46,880 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:46,880 INFO L93 Difference]: Finished difference Result 65 states and 76 transitions. [2018-11-23 12:09:46,880 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 17 states. [2018-11-23 12:09:46,880 INFO L78 Accepts]: Start accepts. Automaton has 17 states. Word has length 30 [2018-11-23 12:09:46,880 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:46,881 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 17 states. [2018-11-23 12:09:46,883 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 17 states to 17 states and 73 transitions. [2018-11-23 12:09:46,883 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 17 states. [2018-11-23 12:09:46,884 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 17 states to 17 states and 73 transitions. [2018-11-23 12:09:46,884 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 17 states and 73 transitions. [2018-11-23 12:09:46,978 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 73 edges. 73 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:46,980 INFO L225 Difference]: With dead ends: 65 [2018-11-23 12:09:46,980 INFO L226 Difference]: Without dead ends: 50 [2018-11-23 12:09:46,981 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 44 GetRequests, 29 SyntacticMatches, 0 SemanticMatches, 15 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.1s TimeCoverageRelationStatistics Valid=136, Invalid=136, Unknown=0, NotChecked=0, Total=272 [2018-11-23 12:09:46,981 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 50 states. [2018-11-23 12:09:47,010 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 50 to 38. [2018-11-23 12:09:47,010 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:47,010 INFO L82 GeneralOperation]: Start isEquivalent. First operand 50 states. Second operand 38 states. [2018-11-23 12:09:47,010 INFO L74 IsIncluded]: Start isIncluded. First operand 50 states. Second operand 38 states. [2018-11-23 12:09:47,010 INFO L87 Difference]: Start difference. First operand 50 states. Second operand 38 states. [2018-11-23 12:09:47,012 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:47,012 INFO L93 Difference]: Finished difference Result 50 states and 56 transitions. [2018-11-23 12:09:47,012 INFO L276 IsEmpty]: Start isEmpty. Operand 50 states and 56 transitions. [2018-11-23 12:09:47,013 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:47,013 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:47,013 INFO L74 IsIncluded]: Start isIncluded. First operand 38 states. Second operand 50 states. [2018-11-23 12:09:47,013 INFO L87 Difference]: Start difference. First operand 38 states. Second operand 50 states. [2018-11-23 12:09:47,014 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:47,014 INFO L93 Difference]: Finished difference Result 50 states and 56 transitions. [2018-11-23 12:09:47,014 INFO L276 IsEmpty]: Start isEmpty. Operand 50 states and 56 transitions. [2018-11-23 12:09:47,015 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:47,015 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:47,015 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:47,015 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:47,015 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 38 states. [2018-11-23 12:09:47,016 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 38 states to 38 states and 40 transitions. [2018-11-23 12:09:47,016 INFO L78 Accepts]: Start accepts. Automaton has 38 states and 40 transitions. Word has length 30 [2018-11-23 12:09:47,017 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:47,017 INFO L480 AbstractCegarLoop]: Abstraction has 38 states and 40 transitions. [2018-11-23 12:09:47,017 INFO L481 AbstractCegarLoop]: Interpolant automaton has 17 states. [2018-11-23 12:09:47,017 INFO L276 IsEmpty]: Start isEmpty. Operand 38 states and 40 transitions. [2018-11-23 12:09:47,017 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 35 [2018-11-23 12:09:47,017 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:47,018 INFO L402 BasicCegarLoop]: trace histogram [15, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:47,018 INFO L423 AbstractCegarLoop]: === Iteration 13 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:47,018 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:47,018 INFO L82 PathProgramCache]: Analyzing trace with hash 1076963082, now seen corresponding path program 10 times [2018-11-23 12:09:47,018 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:47,019 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:47,019 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:47,019 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:47,020 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:47,038 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:47,386 INFO L256 TraceCheckUtils]: 0: Hoare triple {2888#true} call ULTIMATE.init(); {2888#true} is VALID [2018-11-23 12:09:47,387 INFO L273 TraceCheckUtils]: 1: Hoare triple {2888#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {2888#true} is VALID [2018-11-23 12:09:47,387 INFO L273 TraceCheckUtils]: 2: Hoare triple {2888#true} assume true; {2888#true} is VALID [2018-11-23 12:09:47,387 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2888#true} {2888#true} #60#return; {2888#true} is VALID [2018-11-23 12:09:47,387 INFO L256 TraceCheckUtils]: 4: Hoare triple {2888#true} call #t~ret4 := main(); {2888#true} is VALID [2018-11-23 12:09:47,388 INFO L273 TraceCheckUtils]: 5: Hoare triple {2888#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {2890#(= main_~i~0 0)} is VALID [2018-11-23 12:09:47,389 INFO L273 TraceCheckUtils]: 6: Hoare triple {2890#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2891#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:47,389 INFO L273 TraceCheckUtils]: 7: Hoare triple {2891#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2892#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:47,390 INFO L273 TraceCheckUtils]: 8: Hoare triple {2892#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2893#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:47,391 INFO L273 TraceCheckUtils]: 9: Hoare triple {2893#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2894#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:47,391 INFO L273 TraceCheckUtils]: 10: Hoare triple {2894#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2895#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:47,392 INFO L273 TraceCheckUtils]: 11: Hoare triple {2895#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2896#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:47,393 INFO L273 TraceCheckUtils]: 12: Hoare triple {2896#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2897#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:47,394 INFO L273 TraceCheckUtils]: 13: Hoare triple {2897#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2898#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:47,395 INFO L273 TraceCheckUtils]: 14: Hoare triple {2898#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2899#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:47,396 INFO L273 TraceCheckUtils]: 15: Hoare triple {2899#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2900#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:47,397 INFO L273 TraceCheckUtils]: 16: Hoare triple {2900#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2901#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:47,398 INFO L273 TraceCheckUtils]: 17: Hoare triple {2901#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2902#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:47,399 INFO L273 TraceCheckUtils]: 18: Hoare triple {2902#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2903#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:47,400 INFO L273 TraceCheckUtils]: 19: Hoare triple {2903#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2904#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:47,401 INFO L273 TraceCheckUtils]: 20: Hoare triple {2904#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2905#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:47,401 INFO L273 TraceCheckUtils]: 21: Hoare triple {2905#(<= main_~i~0 15)} assume !(~i~0 < 100000); {2889#false} is VALID [2018-11-23 12:09:47,402 INFO L273 TraceCheckUtils]: 22: Hoare triple {2889#false} ~i~0 := 1; {2889#false} is VALID [2018-11-23 12:09:47,402 INFO L273 TraceCheckUtils]: 23: Hoare triple {2889#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:47,402 INFO L273 TraceCheckUtils]: 24: Hoare triple {2889#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:47,402 INFO L273 TraceCheckUtils]: 25: Hoare triple {2889#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:47,402 INFO L273 TraceCheckUtils]: 26: Hoare triple {2889#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:47,403 INFO L273 TraceCheckUtils]: 27: Hoare triple {2889#false} assume !(~i~0 < 100000); {2889#false} is VALID [2018-11-23 12:09:47,403 INFO L273 TraceCheckUtils]: 28: Hoare triple {2889#false} ~i~0 := 1;~j~0 := 0; {2889#false} is VALID [2018-11-23 12:09:47,403 INFO L273 TraceCheckUtils]: 29: Hoare triple {2889#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {2889#false} is VALID [2018-11-23 12:09:47,403 INFO L256 TraceCheckUtils]: 30: Hoare triple {2889#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {2889#false} is VALID [2018-11-23 12:09:47,404 INFO L273 TraceCheckUtils]: 31: Hoare triple {2889#false} ~cond := #in~cond; {2889#false} is VALID [2018-11-23 12:09:47,404 INFO L273 TraceCheckUtils]: 32: Hoare triple {2889#false} assume 0 == ~cond; {2889#false} is VALID [2018-11-23 12:09:47,404 INFO L273 TraceCheckUtils]: 33: Hoare triple {2889#false} assume !false; {2889#false} is VALID [2018-11-23 12:09:47,405 INFO L134 CoverageAnalysis]: Checked inductivity of 130 backedges. 0 proven. 120 refuted. 0 times theorem prover too weak. 10 trivial. 0 not checked. [2018-11-23 12:09:47,405 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:47,406 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 11 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 11 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:47,415 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:09:47,462 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:09:47,462 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:47,488 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:47,490 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:47,690 INFO L256 TraceCheckUtils]: 0: Hoare triple {2888#true} call ULTIMATE.init(); {2888#true} is VALID [2018-11-23 12:09:47,690 INFO L273 TraceCheckUtils]: 1: Hoare triple {2888#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {2888#true} is VALID [2018-11-23 12:09:47,690 INFO L273 TraceCheckUtils]: 2: Hoare triple {2888#true} assume true; {2888#true} is VALID [2018-11-23 12:09:47,691 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2888#true} {2888#true} #60#return; {2888#true} is VALID [2018-11-23 12:09:47,691 INFO L256 TraceCheckUtils]: 4: Hoare triple {2888#true} call #t~ret4 := main(); {2888#true} is VALID [2018-11-23 12:09:47,692 INFO L273 TraceCheckUtils]: 5: Hoare triple {2888#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {2924#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:47,693 INFO L273 TraceCheckUtils]: 6: Hoare triple {2924#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2891#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:47,693 INFO L273 TraceCheckUtils]: 7: Hoare triple {2891#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2892#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:47,694 INFO L273 TraceCheckUtils]: 8: Hoare triple {2892#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2893#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:47,695 INFO L273 TraceCheckUtils]: 9: Hoare triple {2893#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2894#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:47,696 INFO L273 TraceCheckUtils]: 10: Hoare triple {2894#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2895#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:47,696 INFO L273 TraceCheckUtils]: 11: Hoare triple {2895#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2896#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:47,711 INFO L273 TraceCheckUtils]: 12: Hoare triple {2896#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2897#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:47,712 INFO L273 TraceCheckUtils]: 13: Hoare triple {2897#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2898#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:47,713 INFO L273 TraceCheckUtils]: 14: Hoare triple {2898#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2899#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:47,713 INFO L273 TraceCheckUtils]: 15: Hoare triple {2899#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2900#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:47,714 INFO L273 TraceCheckUtils]: 16: Hoare triple {2900#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2901#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:47,715 INFO L273 TraceCheckUtils]: 17: Hoare triple {2901#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2902#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:47,716 INFO L273 TraceCheckUtils]: 18: Hoare triple {2902#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2903#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:47,717 INFO L273 TraceCheckUtils]: 19: Hoare triple {2903#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2904#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:47,718 INFO L273 TraceCheckUtils]: 20: Hoare triple {2904#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {2905#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:47,719 INFO L273 TraceCheckUtils]: 21: Hoare triple {2905#(<= main_~i~0 15)} assume !(~i~0 < 100000); {2889#false} is VALID [2018-11-23 12:09:47,719 INFO L273 TraceCheckUtils]: 22: Hoare triple {2889#false} ~i~0 := 1; {2889#false} is VALID [2018-11-23 12:09:47,719 INFO L273 TraceCheckUtils]: 23: Hoare triple {2889#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:47,719 INFO L273 TraceCheckUtils]: 24: Hoare triple {2889#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:47,719 INFO L273 TraceCheckUtils]: 25: Hoare triple {2889#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:47,720 INFO L273 TraceCheckUtils]: 26: Hoare triple {2889#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:47,720 INFO L273 TraceCheckUtils]: 27: Hoare triple {2889#false} assume !(~i~0 < 100000); {2889#false} is VALID [2018-11-23 12:09:47,720 INFO L273 TraceCheckUtils]: 28: Hoare triple {2889#false} ~i~0 := 1;~j~0 := 0; {2889#false} is VALID [2018-11-23 12:09:47,720 INFO L273 TraceCheckUtils]: 29: Hoare triple {2889#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {2889#false} is VALID [2018-11-23 12:09:47,720 INFO L256 TraceCheckUtils]: 30: Hoare triple {2889#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {2889#false} is VALID [2018-11-23 12:09:47,721 INFO L273 TraceCheckUtils]: 31: Hoare triple {2889#false} ~cond := #in~cond; {2889#false} is VALID [2018-11-23 12:09:47,721 INFO L273 TraceCheckUtils]: 32: Hoare triple {2889#false} assume 0 == ~cond; {2889#false} is VALID [2018-11-23 12:09:47,721 INFO L273 TraceCheckUtils]: 33: Hoare triple {2889#false} assume !false; {2889#false} is VALID [2018-11-23 12:09:47,722 INFO L134 CoverageAnalysis]: Checked inductivity of 130 backedges. 0 proven. 120 refuted. 0 times theorem prover too weak. 10 trivial. 0 not checked. [2018-11-23 12:09:47,742 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:47,742 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [18, 18] total 19 [2018-11-23 12:09:47,742 INFO L78 Accepts]: Start accepts. Automaton has 19 states. Word has length 34 [2018-11-23 12:09:47,743 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:47,743 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 19 states. [2018-11-23 12:09:47,770 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 33 edges. 33 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:47,770 INFO L459 AbstractCegarLoop]: Interpolant automaton has 19 states [2018-11-23 12:09:47,771 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 19 interpolants. [2018-11-23 12:09:47,771 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=171, Invalid=171, Unknown=0, NotChecked=0, Total=342 [2018-11-23 12:09:47,771 INFO L87 Difference]: Start difference. First operand 38 states and 40 transitions. Second operand 19 states. [2018-11-23 12:09:48,446 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:48,447 INFO L93 Difference]: Finished difference Result 61 states and 67 transitions. [2018-11-23 12:09:48,447 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 18 states. [2018-11-23 12:09:48,447 INFO L78 Accepts]: Start accepts. Automaton has 19 states. Word has length 34 [2018-11-23 12:09:48,447 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:48,448 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 19 states. [2018-11-23 12:09:48,449 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 18 states to 18 states and 61 transitions. [2018-11-23 12:09:48,449 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 19 states. [2018-11-23 12:09:48,451 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 18 states to 18 states and 61 transitions. [2018-11-23 12:09:48,451 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 18 states and 61 transitions. [2018-11-23 12:09:48,541 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 61 edges. 61 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:48,542 INFO L225 Difference]: With dead ends: 61 [2018-11-23 12:09:48,543 INFO L226 Difference]: Without dead ends: 45 [2018-11-23 12:09:48,544 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 51 GetRequests, 34 SyntacticMatches, 0 SemanticMatches, 17 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 28 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=171, Invalid=171, Unknown=0, NotChecked=0, Total=342 [2018-11-23 12:09:48,544 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 45 states. [2018-11-23 12:09:48,578 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 45 to 39. [2018-11-23 12:09:48,578 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:48,579 INFO L82 GeneralOperation]: Start isEquivalent. First operand 45 states. Second operand 39 states. [2018-11-23 12:09:48,579 INFO L74 IsIncluded]: Start isIncluded. First operand 45 states. Second operand 39 states. [2018-11-23 12:09:48,579 INFO L87 Difference]: Start difference. First operand 45 states. Second operand 39 states. [2018-11-23 12:09:48,581 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:48,581 INFO L93 Difference]: Finished difference Result 45 states and 49 transitions. [2018-11-23 12:09:48,581 INFO L276 IsEmpty]: Start isEmpty. Operand 45 states and 49 transitions. [2018-11-23 12:09:48,581 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:48,582 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:48,582 INFO L74 IsIncluded]: Start isIncluded. First operand 39 states. Second operand 45 states. [2018-11-23 12:09:48,582 INFO L87 Difference]: Start difference. First operand 39 states. Second operand 45 states. [2018-11-23 12:09:48,583 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:48,583 INFO L93 Difference]: Finished difference Result 45 states and 49 transitions. [2018-11-23 12:09:48,583 INFO L276 IsEmpty]: Start isEmpty. Operand 45 states and 49 transitions. [2018-11-23 12:09:48,584 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:48,584 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:48,584 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:48,584 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:48,584 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 39 states. [2018-11-23 12:09:48,585 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 39 states to 39 states and 41 transitions. [2018-11-23 12:09:48,585 INFO L78 Accepts]: Start accepts. Automaton has 39 states and 41 transitions. Word has length 34 [2018-11-23 12:09:48,585 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:48,585 INFO L480 AbstractCegarLoop]: Abstraction has 39 states and 41 transitions. [2018-11-23 12:09:48,585 INFO L481 AbstractCegarLoop]: Interpolant automaton has 19 states. [2018-11-23 12:09:48,586 INFO L276 IsEmpty]: Start isEmpty. Operand 39 states and 41 transitions. [2018-11-23 12:09:48,586 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 36 [2018-11-23 12:09:48,586 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:48,586 INFO L402 BasicCegarLoop]: trace histogram [16, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:48,587 INFO L423 AbstractCegarLoop]: === Iteration 14 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:48,587 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:48,587 INFO L82 PathProgramCache]: Analyzing trace with hash 790780006, now seen corresponding path program 11 times [2018-11-23 12:09:48,587 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:48,587 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:48,588 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:48,588 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:48,589 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:48,607 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:49,139 INFO L256 TraceCheckUtils]: 0: Hoare triple {3268#true} call ULTIMATE.init(); {3268#true} is VALID [2018-11-23 12:09:49,139 INFO L273 TraceCheckUtils]: 1: Hoare triple {3268#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {3268#true} is VALID [2018-11-23 12:09:49,140 INFO L273 TraceCheckUtils]: 2: Hoare triple {3268#true} assume true; {3268#true} is VALID [2018-11-23 12:09:49,140 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3268#true} {3268#true} #60#return; {3268#true} is VALID [2018-11-23 12:09:49,140 INFO L256 TraceCheckUtils]: 4: Hoare triple {3268#true} call #t~ret4 := main(); {3268#true} is VALID [2018-11-23 12:09:49,141 INFO L273 TraceCheckUtils]: 5: Hoare triple {3268#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {3270#(= main_~i~0 0)} is VALID [2018-11-23 12:09:49,142 INFO L273 TraceCheckUtils]: 6: Hoare triple {3270#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3271#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:49,144 INFO L273 TraceCheckUtils]: 7: Hoare triple {3271#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3272#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:49,145 INFO L273 TraceCheckUtils]: 8: Hoare triple {3272#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3273#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:49,146 INFO L273 TraceCheckUtils]: 9: Hoare triple {3273#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3274#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:49,147 INFO L273 TraceCheckUtils]: 10: Hoare triple {3274#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3275#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:49,149 INFO L273 TraceCheckUtils]: 11: Hoare triple {3275#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3276#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:49,150 INFO L273 TraceCheckUtils]: 12: Hoare triple {3276#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3277#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:49,151 INFO L273 TraceCheckUtils]: 13: Hoare triple {3277#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3278#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:49,152 INFO L273 TraceCheckUtils]: 14: Hoare triple {3278#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3279#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:49,154 INFO L273 TraceCheckUtils]: 15: Hoare triple {3279#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3280#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:49,155 INFO L273 TraceCheckUtils]: 16: Hoare triple {3280#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3281#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:49,156 INFO L273 TraceCheckUtils]: 17: Hoare triple {3281#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3282#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:49,157 INFO L273 TraceCheckUtils]: 18: Hoare triple {3282#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3283#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:49,159 INFO L273 TraceCheckUtils]: 19: Hoare triple {3283#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3284#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:49,160 INFO L273 TraceCheckUtils]: 20: Hoare triple {3284#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3285#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:49,161 INFO L273 TraceCheckUtils]: 21: Hoare triple {3285#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3286#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:49,162 INFO L273 TraceCheckUtils]: 22: Hoare triple {3286#(<= main_~i~0 16)} assume !(~i~0 < 100000); {3269#false} is VALID [2018-11-23 12:09:49,162 INFO L273 TraceCheckUtils]: 23: Hoare triple {3269#false} ~i~0 := 1; {3269#false} is VALID [2018-11-23 12:09:49,163 INFO L273 TraceCheckUtils]: 24: Hoare triple {3269#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3269#false} is VALID [2018-11-23 12:09:49,163 INFO L273 TraceCheckUtils]: 25: Hoare triple {3269#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3269#false} is VALID [2018-11-23 12:09:49,163 INFO L273 TraceCheckUtils]: 26: Hoare triple {3269#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3269#false} is VALID [2018-11-23 12:09:49,164 INFO L273 TraceCheckUtils]: 27: Hoare triple {3269#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3269#false} is VALID [2018-11-23 12:09:49,164 INFO L273 TraceCheckUtils]: 28: Hoare triple {3269#false} assume !(~i~0 < 100000); {3269#false} is VALID [2018-11-23 12:09:49,164 INFO L273 TraceCheckUtils]: 29: Hoare triple {3269#false} ~i~0 := 1;~j~0 := 0; {3269#false} is VALID [2018-11-23 12:09:49,164 INFO L273 TraceCheckUtils]: 30: Hoare triple {3269#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {3269#false} is VALID [2018-11-23 12:09:49,165 INFO L256 TraceCheckUtils]: 31: Hoare triple {3269#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {3269#false} is VALID [2018-11-23 12:09:49,165 INFO L273 TraceCheckUtils]: 32: Hoare triple {3269#false} ~cond := #in~cond; {3269#false} is VALID [2018-11-23 12:09:49,165 INFO L273 TraceCheckUtils]: 33: Hoare triple {3269#false} assume 0 == ~cond; {3269#false} is VALID [2018-11-23 12:09:49,166 INFO L273 TraceCheckUtils]: 34: Hoare triple {3269#false} assume !false; {3269#false} is VALID [2018-11-23 12:09:49,168 INFO L134 CoverageAnalysis]: Checked inductivity of 146 backedges. 0 proven. 136 refuted. 0 times theorem prover too weak. 10 trivial. 0 not checked. [2018-11-23 12:09:49,168 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:49,168 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 12 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 12 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:49,177 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:09:49,290 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 9 check-sat command(s) [2018-11-23 12:09:49,291 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:49,316 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:49,318 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:49,506 INFO L256 TraceCheckUtils]: 0: Hoare triple {3268#true} call ULTIMATE.init(); {3268#true} is VALID [2018-11-23 12:09:49,507 INFO L273 TraceCheckUtils]: 1: Hoare triple {3268#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {3268#true} is VALID [2018-11-23 12:09:49,507 INFO L273 TraceCheckUtils]: 2: Hoare triple {3268#true} assume true; {3268#true} is VALID [2018-11-23 12:09:49,507 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3268#true} {3268#true} #60#return; {3268#true} is VALID [2018-11-23 12:09:49,508 INFO L256 TraceCheckUtils]: 4: Hoare triple {3268#true} call #t~ret4 := main(); {3268#true} is VALID [2018-11-23 12:09:49,509 INFO L273 TraceCheckUtils]: 5: Hoare triple {3268#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {3305#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:49,509 INFO L273 TraceCheckUtils]: 6: Hoare triple {3305#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3271#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:49,510 INFO L273 TraceCheckUtils]: 7: Hoare triple {3271#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3272#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:49,511 INFO L273 TraceCheckUtils]: 8: Hoare triple {3272#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3273#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:49,511 INFO L273 TraceCheckUtils]: 9: Hoare triple {3273#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3274#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:49,512 INFO L273 TraceCheckUtils]: 10: Hoare triple {3274#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3275#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:49,514 INFO L273 TraceCheckUtils]: 11: Hoare triple {3275#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3276#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:49,517 INFO L273 TraceCheckUtils]: 12: Hoare triple {3276#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3277#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:49,517 INFO L273 TraceCheckUtils]: 13: Hoare triple {3277#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3278#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:49,518 INFO L273 TraceCheckUtils]: 14: Hoare triple {3278#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3279#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:49,519 INFO L273 TraceCheckUtils]: 15: Hoare triple {3279#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3280#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:49,519 INFO L273 TraceCheckUtils]: 16: Hoare triple {3280#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3281#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:49,530 INFO L273 TraceCheckUtils]: 17: Hoare triple {3281#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3282#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:49,532 INFO L273 TraceCheckUtils]: 18: Hoare triple {3282#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3283#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:49,532 INFO L273 TraceCheckUtils]: 19: Hoare triple {3283#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3284#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:49,534 INFO L273 TraceCheckUtils]: 20: Hoare triple {3284#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3285#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:49,535 INFO L273 TraceCheckUtils]: 21: Hoare triple {3285#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3286#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:49,536 INFO L273 TraceCheckUtils]: 22: Hoare triple {3286#(<= main_~i~0 16)} assume !(~i~0 < 100000); {3269#false} is VALID [2018-11-23 12:09:49,536 INFO L273 TraceCheckUtils]: 23: Hoare triple {3269#false} ~i~0 := 1; {3269#false} is VALID [2018-11-23 12:09:49,536 INFO L273 TraceCheckUtils]: 24: Hoare triple {3269#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3269#false} is VALID [2018-11-23 12:09:49,536 INFO L273 TraceCheckUtils]: 25: Hoare triple {3269#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3269#false} is VALID [2018-11-23 12:09:49,537 INFO L273 TraceCheckUtils]: 26: Hoare triple {3269#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3269#false} is VALID [2018-11-23 12:09:49,537 INFO L273 TraceCheckUtils]: 27: Hoare triple {3269#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3269#false} is VALID [2018-11-23 12:09:49,537 INFO L273 TraceCheckUtils]: 28: Hoare triple {3269#false} assume !(~i~0 < 100000); {3269#false} is VALID [2018-11-23 12:09:49,537 INFO L273 TraceCheckUtils]: 29: Hoare triple {3269#false} ~i~0 := 1;~j~0 := 0; {3269#false} is VALID [2018-11-23 12:09:49,537 INFO L273 TraceCheckUtils]: 30: Hoare triple {3269#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {3269#false} is VALID [2018-11-23 12:09:49,538 INFO L256 TraceCheckUtils]: 31: Hoare triple {3269#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {3269#false} is VALID [2018-11-23 12:09:49,538 INFO L273 TraceCheckUtils]: 32: Hoare triple {3269#false} ~cond := #in~cond; {3269#false} is VALID [2018-11-23 12:09:49,538 INFO L273 TraceCheckUtils]: 33: Hoare triple {3269#false} assume 0 == ~cond; {3269#false} is VALID [2018-11-23 12:09:49,538 INFO L273 TraceCheckUtils]: 34: Hoare triple {3269#false} assume !false; {3269#false} is VALID [2018-11-23 12:09:49,539 INFO L134 CoverageAnalysis]: Checked inductivity of 146 backedges. 0 proven. 136 refuted. 0 times theorem prover too weak. 10 trivial. 0 not checked. [2018-11-23 12:09:49,561 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:49,561 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [19, 19] total 20 [2018-11-23 12:09:49,561 INFO L78 Accepts]: Start accepts. Automaton has 20 states. Word has length 35 [2018-11-23 12:09:49,562 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:49,562 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 20 states. [2018-11-23 12:09:49,597 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 12:09:49,598 INFO L459 AbstractCegarLoop]: Interpolant automaton has 20 states [2018-11-23 12:09:49,598 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 20 interpolants. [2018-11-23 12:09:49,599 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=190, Invalid=190, Unknown=0, NotChecked=0, Total=380 [2018-11-23 12:09:49,599 INFO L87 Difference]: Start difference. First operand 39 states and 41 transitions. Second operand 20 states. [2018-11-23 12:09:50,084 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:50,084 INFO L93 Difference]: Finished difference Result 62 states and 68 transitions. [2018-11-23 12:09:50,084 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 19 states. [2018-11-23 12:09:50,084 INFO L78 Accepts]: Start accepts. Automaton has 20 states. Word has length 35 [2018-11-23 12:09:50,085 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:50,085 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 20 states. [2018-11-23 12:09:50,086 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 19 states to 19 states and 62 transitions. [2018-11-23 12:09:50,086 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 20 states. [2018-11-23 12:09:50,087 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 19 states to 19 states and 62 transitions. [2018-11-23 12:09:50,087 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 19 states and 62 transitions. [2018-11-23 12:09:50,175 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 62 edges. 62 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:50,176 INFO L225 Difference]: With dead ends: 62 [2018-11-23 12:09:50,176 INFO L226 Difference]: Without dead ends: 46 [2018-11-23 12:09:50,177 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 53 GetRequests, 35 SyntacticMatches, 0 SemanticMatches, 18 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 30 ImplicationChecksByTransitivity, 0.3s TimeCoverageRelationStatistics Valid=190, Invalid=190, Unknown=0, NotChecked=0, Total=380 [2018-11-23 12:09:50,178 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 46 states. [2018-11-23 12:09:50,205 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 46 to 40. [2018-11-23 12:09:50,206 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:50,206 INFO L82 GeneralOperation]: Start isEquivalent. First operand 46 states. Second operand 40 states. [2018-11-23 12:09:50,206 INFO L74 IsIncluded]: Start isIncluded. First operand 46 states. Second operand 40 states. [2018-11-23 12:09:50,206 INFO L87 Difference]: Start difference. First operand 46 states. Second operand 40 states. [2018-11-23 12:09:50,208 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:50,208 INFO L93 Difference]: Finished difference Result 46 states and 50 transitions. [2018-11-23 12:09:50,208 INFO L276 IsEmpty]: Start isEmpty. Operand 46 states and 50 transitions. [2018-11-23 12:09:50,209 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:50,209 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:50,209 INFO L74 IsIncluded]: Start isIncluded. First operand 40 states. Second operand 46 states. [2018-11-23 12:09:50,209 INFO L87 Difference]: Start difference. First operand 40 states. Second operand 46 states. [2018-11-23 12:09:50,210 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:50,210 INFO L93 Difference]: Finished difference Result 46 states and 50 transitions. [2018-11-23 12:09:50,210 INFO L276 IsEmpty]: Start isEmpty. Operand 46 states and 50 transitions. [2018-11-23 12:09:50,211 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:50,211 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:50,211 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:50,211 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:50,211 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 40 states. [2018-11-23 12:09:50,212 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 40 states to 40 states and 42 transitions. [2018-11-23 12:09:50,212 INFO L78 Accepts]: Start accepts. Automaton has 40 states and 42 transitions. Word has length 35 [2018-11-23 12:09:50,212 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:50,212 INFO L480 AbstractCegarLoop]: Abstraction has 40 states and 42 transitions. [2018-11-23 12:09:50,212 INFO L481 AbstractCegarLoop]: Interpolant automaton has 20 states. [2018-11-23 12:09:50,212 INFO L276 IsEmpty]: Start isEmpty. Operand 40 states and 42 transitions. [2018-11-23 12:09:50,213 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 37 [2018-11-23 12:09:50,213 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:50,213 INFO L402 BasicCegarLoop]: trace histogram [17, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:50,213 INFO L423 AbstractCegarLoop]: === Iteration 15 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:50,213 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:50,213 INFO L82 PathProgramCache]: Analyzing trace with hash 509039242, now seen corresponding path program 12 times [2018-11-23 12:09:50,213 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:50,213 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:50,214 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:50,214 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:50,214 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:50,230 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:50,899 INFO L256 TraceCheckUtils]: 0: Hoare triple {3658#true} call ULTIMATE.init(); {3658#true} is VALID [2018-11-23 12:09:50,899 INFO L273 TraceCheckUtils]: 1: Hoare triple {3658#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {3658#true} is VALID [2018-11-23 12:09:50,900 INFO L273 TraceCheckUtils]: 2: Hoare triple {3658#true} assume true; {3658#true} is VALID [2018-11-23 12:09:50,900 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3658#true} {3658#true} #60#return; {3658#true} is VALID [2018-11-23 12:09:50,900 INFO L256 TraceCheckUtils]: 4: Hoare triple {3658#true} call #t~ret4 := main(); {3658#true} is VALID [2018-11-23 12:09:50,900 INFO L273 TraceCheckUtils]: 5: Hoare triple {3658#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {3660#(= main_~i~0 0)} is VALID [2018-11-23 12:09:50,901 INFO L273 TraceCheckUtils]: 6: Hoare triple {3660#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3661#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:50,902 INFO L273 TraceCheckUtils]: 7: Hoare triple {3661#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3662#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:50,903 INFO L273 TraceCheckUtils]: 8: Hoare triple {3662#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3663#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:50,904 INFO L273 TraceCheckUtils]: 9: Hoare triple {3663#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3664#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:50,905 INFO L273 TraceCheckUtils]: 10: Hoare triple {3664#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3665#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:50,906 INFO L273 TraceCheckUtils]: 11: Hoare triple {3665#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3666#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:50,907 INFO L273 TraceCheckUtils]: 12: Hoare triple {3666#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3667#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:50,909 INFO L273 TraceCheckUtils]: 13: Hoare triple {3667#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3668#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:50,910 INFO L273 TraceCheckUtils]: 14: Hoare triple {3668#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3669#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:50,911 INFO L273 TraceCheckUtils]: 15: Hoare triple {3669#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3670#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:50,912 INFO L273 TraceCheckUtils]: 16: Hoare triple {3670#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3671#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:50,913 INFO L273 TraceCheckUtils]: 17: Hoare triple {3671#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3672#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:50,914 INFO L273 TraceCheckUtils]: 18: Hoare triple {3672#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3673#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:50,915 INFO L273 TraceCheckUtils]: 19: Hoare triple {3673#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3674#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:50,916 INFO L273 TraceCheckUtils]: 20: Hoare triple {3674#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3675#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:50,917 INFO L273 TraceCheckUtils]: 21: Hoare triple {3675#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3676#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:50,918 INFO L273 TraceCheckUtils]: 22: Hoare triple {3676#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3677#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:50,918 INFO L273 TraceCheckUtils]: 23: Hoare triple {3677#(<= main_~i~0 17)} assume !(~i~0 < 100000); {3659#false} is VALID [2018-11-23 12:09:50,919 INFO L273 TraceCheckUtils]: 24: Hoare triple {3659#false} ~i~0 := 1; {3659#false} is VALID [2018-11-23 12:09:50,919 INFO L273 TraceCheckUtils]: 25: Hoare triple {3659#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3659#false} is VALID [2018-11-23 12:09:50,919 INFO L273 TraceCheckUtils]: 26: Hoare triple {3659#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3659#false} is VALID [2018-11-23 12:09:50,919 INFO L273 TraceCheckUtils]: 27: Hoare triple {3659#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3659#false} is VALID [2018-11-23 12:09:50,919 INFO L273 TraceCheckUtils]: 28: Hoare triple {3659#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3659#false} is VALID [2018-11-23 12:09:50,920 INFO L273 TraceCheckUtils]: 29: Hoare triple {3659#false} assume !(~i~0 < 100000); {3659#false} is VALID [2018-11-23 12:09:50,920 INFO L273 TraceCheckUtils]: 30: Hoare triple {3659#false} ~i~0 := 1;~j~0 := 0; {3659#false} is VALID [2018-11-23 12:09:50,920 INFO L273 TraceCheckUtils]: 31: Hoare triple {3659#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {3659#false} is VALID [2018-11-23 12:09:50,920 INFO L256 TraceCheckUtils]: 32: Hoare triple {3659#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {3659#false} is VALID [2018-11-23 12:09:50,920 INFO L273 TraceCheckUtils]: 33: Hoare triple {3659#false} ~cond := #in~cond; {3659#false} is VALID [2018-11-23 12:09:50,920 INFO L273 TraceCheckUtils]: 34: Hoare triple {3659#false} assume 0 == ~cond; {3659#false} is VALID [2018-11-23 12:09:50,921 INFO L273 TraceCheckUtils]: 35: Hoare triple {3659#false} assume !false; {3659#false} is VALID [2018-11-23 12:09:50,921 INFO L134 CoverageAnalysis]: Checked inductivity of 163 backedges. 0 proven. 153 refuted. 0 times theorem prover too weak. 10 trivial. 0 not checked. [2018-11-23 12:09:50,922 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:50,922 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 13 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 13 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:50,930 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE [2018-11-23 12:09:50,969 INFO L249 tOrderPrioritization]: Assert order MIX_INSIDE_OUTSIDE issued 5 check-sat command(s) [2018-11-23 12:09:50,970 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:50,978 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:50,980 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:51,086 INFO L256 TraceCheckUtils]: 0: Hoare triple {3658#true} call ULTIMATE.init(); {3658#true} is VALID [2018-11-23 12:09:51,086 INFO L273 TraceCheckUtils]: 1: Hoare triple {3658#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {3658#true} is VALID [2018-11-23 12:09:51,086 INFO L273 TraceCheckUtils]: 2: Hoare triple {3658#true} assume true; {3658#true} is VALID [2018-11-23 12:09:51,086 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3658#true} {3658#true} #60#return; {3658#true} is VALID [2018-11-23 12:09:51,087 INFO L256 TraceCheckUtils]: 4: Hoare triple {3658#true} call #t~ret4 := main(); {3658#true} is VALID [2018-11-23 12:09:51,087 INFO L273 TraceCheckUtils]: 5: Hoare triple {3658#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {3658#true} is VALID [2018-11-23 12:09:51,087 INFO L273 TraceCheckUtils]: 6: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,087 INFO L273 TraceCheckUtils]: 7: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,088 INFO L273 TraceCheckUtils]: 8: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,088 INFO L273 TraceCheckUtils]: 9: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,088 INFO L273 TraceCheckUtils]: 10: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,088 INFO L273 TraceCheckUtils]: 11: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,088 INFO L273 TraceCheckUtils]: 12: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,088 INFO L273 TraceCheckUtils]: 13: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,089 INFO L273 TraceCheckUtils]: 14: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,089 INFO L273 TraceCheckUtils]: 15: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,089 INFO L273 TraceCheckUtils]: 16: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,089 INFO L273 TraceCheckUtils]: 17: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,089 INFO L273 TraceCheckUtils]: 18: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,089 INFO L273 TraceCheckUtils]: 19: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,089 INFO L273 TraceCheckUtils]: 20: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,090 INFO L273 TraceCheckUtils]: 21: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,090 INFO L273 TraceCheckUtils]: 22: Hoare triple {3658#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3658#true} is VALID [2018-11-23 12:09:51,090 INFO L273 TraceCheckUtils]: 23: Hoare triple {3658#true} assume !(~i~0 < 100000); {3658#true} is VALID [2018-11-23 12:09:51,109 INFO L273 TraceCheckUtils]: 24: Hoare triple {3658#true} ~i~0 := 1; {3661#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:51,111 INFO L273 TraceCheckUtils]: 25: Hoare triple {3661#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3670#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:51,112 INFO L273 TraceCheckUtils]: 26: Hoare triple {3670#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3759#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:51,113 INFO L273 TraceCheckUtils]: 27: Hoare triple {3759#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3763#(<= main_~i~0 28)} is VALID [2018-11-23 12:09:51,113 INFO L273 TraceCheckUtils]: 28: Hoare triple {3763#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {3767#(<= main_~i~0 37)} is VALID [2018-11-23 12:09:51,114 INFO L273 TraceCheckUtils]: 29: Hoare triple {3767#(<= main_~i~0 37)} assume !(~i~0 < 100000); {3659#false} is VALID [2018-11-23 12:09:51,114 INFO L273 TraceCheckUtils]: 30: Hoare triple {3659#false} ~i~0 := 1;~j~0 := 0; {3659#false} is VALID [2018-11-23 12:09:51,114 INFO L273 TraceCheckUtils]: 31: Hoare triple {3659#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {3659#false} is VALID [2018-11-23 12:09:51,114 INFO L256 TraceCheckUtils]: 32: Hoare triple {3659#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {3659#false} is VALID [2018-11-23 12:09:51,114 INFO L273 TraceCheckUtils]: 33: Hoare triple {3659#false} ~cond := #in~cond; {3659#false} is VALID [2018-11-23 12:09:51,115 INFO L273 TraceCheckUtils]: 34: Hoare triple {3659#false} assume 0 == ~cond; {3659#false} is VALID [2018-11-23 12:09:51,115 INFO L273 TraceCheckUtils]: 35: Hoare triple {3659#false} assume !false; {3659#false} is VALID [2018-11-23 12:09:51,115 INFO L134 CoverageAnalysis]: Checked inductivity of 163 backedges. 0 proven. 10 refuted. 0 times theorem prover too weak. 153 trivial. 0 not checked. [2018-11-23 12:09:51,135 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:51,135 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [20, 7] total 23 [2018-11-23 12:09:51,136 INFO L78 Accepts]: Start accepts. Automaton has 23 states. Word has length 36 [2018-11-23 12:09:51,136 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:51,136 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 23 states. [2018-11-23 12:09:51,175 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 42 edges. 42 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:51,175 INFO L459 AbstractCegarLoop]: Interpolant automaton has 23 states [2018-11-23 12:09:51,176 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 23 interpolants. [2018-11-23 12:09:51,176 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=253, Invalid=253, Unknown=0, NotChecked=0, Total=506 [2018-11-23 12:09:51,176 INFO L87 Difference]: Start difference. First operand 40 states and 42 transitions. Second operand 23 states. [2018-11-23 12:09:51,802 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:51,802 INFO L93 Difference]: Finished difference Result 76 states and 89 transitions. [2018-11-23 12:09:51,802 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 23 states. [2018-11-23 12:09:51,802 INFO L78 Accepts]: Start accepts. Automaton has 23 states. Word has length 36 [2018-11-23 12:09:51,802 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:51,803 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 23 states. [2018-11-23 12:09:51,805 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 23 states to 23 states and 85 transitions. [2018-11-23 12:09:51,805 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 23 states. [2018-11-23 12:09:51,807 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 23 states to 23 states and 85 transitions. [2018-11-23 12:09:51,807 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 23 states and 85 transitions. [2018-11-23 12:09:51,903 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 85 edges. 85 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:51,905 INFO L225 Difference]: With dead ends: 76 [2018-11-23 12:09:51,905 INFO L226 Difference]: Without dead ends: 60 [2018-11-23 12:09:51,906 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 55 GetRequests, 34 SyntacticMatches, 0 SemanticMatches, 21 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.5s TimeCoverageRelationStatistics Valid=253, Invalid=253, Unknown=0, NotChecked=0, Total=506 [2018-11-23 12:09:51,906 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 60 states. [2018-11-23 12:09:51,937 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 60 to 45. [2018-11-23 12:09:51,938 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:51,938 INFO L82 GeneralOperation]: Start isEquivalent. First operand 60 states. Second operand 45 states. [2018-11-23 12:09:51,938 INFO L74 IsIncluded]: Start isIncluded. First operand 60 states. Second operand 45 states. [2018-11-23 12:09:51,938 INFO L87 Difference]: Start difference. First operand 60 states. Second operand 45 states. [2018-11-23 12:09:51,941 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:51,941 INFO L93 Difference]: Finished difference Result 60 states and 67 transitions. [2018-11-23 12:09:51,941 INFO L276 IsEmpty]: Start isEmpty. Operand 60 states and 67 transitions. [2018-11-23 12:09:51,942 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:51,942 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:51,942 INFO L74 IsIncluded]: Start isIncluded. First operand 45 states. Second operand 60 states. [2018-11-23 12:09:51,942 INFO L87 Difference]: Start difference. First operand 45 states. Second operand 60 states. [2018-11-23 12:09:51,944 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:51,944 INFO L93 Difference]: Finished difference Result 60 states and 67 transitions. [2018-11-23 12:09:51,944 INFO L276 IsEmpty]: Start isEmpty. Operand 60 states and 67 transitions. [2018-11-23 12:09:51,945 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:51,945 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:51,945 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:51,945 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:51,945 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 45 states. [2018-11-23 12:09:51,946 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 45 states to 45 states and 47 transitions. [2018-11-23 12:09:51,947 INFO L78 Accepts]: Start accepts. Automaton has 45 states and 47 transitions. Word has length 36 [2018-11-23 12:09:51,947 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:51,947 INFO L480 AbstractCegarLoop]: Abstraction has 45 states and 47 transitions. [2018-11-23 12:09:51,947 INFO L481 AbstractCegarLoop]: Interpolant automaton has 23 states. [2018-11-23 12:09:51,947 INFO L276 IsEmpty]: Start isEmpty. Operand 45 states and 47 transitions. [2018-11-23 12:09:51,948 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 42 [2018-11-23 12:09:51,948 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:51,948 INFO L402 BasicCegarLoop]: trace histogram [21, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:51,948 INFO L423 AbstractCegarLoop]: === Iteration 16 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:51,948 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:51,949 INFO L82 PathProgramCache]: Analyzing trace with hash 782248453, now seen corresponding path program 13 times [2018-11-23 12:09:51,949 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:51,949 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:51,950 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:51,950 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:51,950 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:51,970 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:52,691 INFO L256 TraceCheckUtils]: 0: Hoare triple {4117#true} call ULTIMATE.init(); {4117#true} is VALID [2018-11-23 12:09:52,692 INFO L273 TraceCheckUtils]: 1: Hoare triple {4117#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {4117#true} is VALID [2018-11-23 12:09:52,692 INFO L273 TraceCheckUtils]: 2: Hoare triple {4117#true} assume true; {4117#true} is VALID [2018-11-23 12:09:52,692 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {4117#true} {4117#true} #60#return; {4117#true} is VALID [2018-11-23 12:09:52,693 INFO L256 TraceCheckUtils]: 4: Hoare triple {4117#true} call #t~ret4 := main(); {4117#true} is VALID [2018-11-23 12:09:52,693 INFO L273 TraceCheckUtils]: 5: Hoare triple {4117#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {4119#(= main_~i~0 0)} is VALID [2018-11-23 12:09:52,694 INFO L273 TraceCheckUtils]: 6: Hoare triple {4119#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4120#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:52,695 INFO L273 TraceCheckUtils]: 7: Hoare triple {4120#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4121#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:52,696 INFO L273 TraceCheckUtils]: 8: Hoare triple {4121#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4122#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:52,697 INFO L273 TraceCheckUtils]: 9: Hoare triple {4122#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4123#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:52,698 INFO L273 TraceCheckUtils]: 10: Hoare triple {4123#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4124#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:52,699 INFO L273 TraceCheckUtils]: 11: Hoare triple {4124#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4125#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:52,700 INFO L273 TraceCheckUtils]: 12: Hoare triple {4125#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4126#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:52,701 INFO L273 TraceCheckUtils]: 13: Hoare triple {4126#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4127#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:52,702 INFO L273 TraceCheckUtils]: 14: Hoare triple {4127#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4128#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:52,703 INFO L273 TraceCheckUtils]: 15: Hoare triple {4128#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4129#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:52,704 INFO L273 TraceCheckUtils]: 16: Hoare triple {4129#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4130#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:52,705 INFO L273 TraceCheckUtils]: 17: Hoare triple {4130#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4131#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:52,706 INFO L273 TraceCheckUtils]: 18: Hoare triple {4131#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4132#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:52,707 INFO L273 TraceCheckUtils]: 19: Hoare triple {4132#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4133#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:52,708 INFO L273 TraceCheckUtils]: 20: Hoare triple {4133#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4134#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:52,709 INFO L273 TraceCheckUtils]: 21: Hoare triple {4134#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4135#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:52,710 INFO L273 TraceCheckUtils]: 22: Hoare triple {4135#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4136#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:52,712 INFO L273 TraceCheckUtils]: 23: Hoare triple {4136#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4137#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:52,713 INFO L273 TraceCheckUtils]: 24: Hoare triple {4137#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4138#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:52,714 INFO L273 TraceCheckUtils]: 25: Hoare triple {4138#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4139#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:52,715 INFO L273 TraceCheckUtils]: 26: Hoare triple {4139#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4140#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:52,715 INFO L273 TraceCheckUtils]: 27: Hoare triple {4140#(<= main_~i~0 21)} assume !(~i~0 < 100000); {4118#false} is VALID [2018-11-23 12:09:52,716 INFO L273 TraceCheckUtils]: 28: Hoare triple {4118#false} ~i~0 := 1; {4118#false} is VALID [2018-11-23 12:09:52,716 INFO L273 TraceCheckUtils]: 29: Hoare triple {4118#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4118#false} is VALID [2018-11-23 12:09:52,716 INFO L273 TraceCheckUtils]: 30: Hoare triple {4118#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4118#false} is VALID [2018-11-23 12:09:52,716 INFO L273 TraceCheckUtils]: 31: Hoare triple {4118#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4118#false} is VALID [2018-11-23 12:09:52,716 INFO L273 TraceCheckUtils]: 32: Hoare triple {4118#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4118#false} is VALID [2018-11-23 12:09:52,717 INFO L273 TraceCheckUtils]: 33: Hoare triple {4118#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4118#false} is VALID [2018-11-23 12:09:52,717 INFO L273 TraceCheckUtils]: 34: Hoare triple {4118#false} assume !(~i~0 < 100000); {4118#false} is VALID [2018-11-23 12:09:52,717 INFO L273 TraceCheckUtils]: 35: Hoare triple {4118#false} ~i~0 := 1;~j~0 := 0; {4118#false} is VALID [2018-11-23 12:09:52,717 INFO L273 TraceCheckUtils]: 36: Hoare triple {4118#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {4118#false} is VALID [2018-11-23 12:09:52,717 INFO L256 TraceCheckUtils]: 37: Hoare triple {4118#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {4118#false} is VALID [2018-11-23 12:09:52,718 INFO L273 TraceCheckUtils]: 38: Hoare triple {4118#false} ~cond := #in~cond; {4118#false} is VALID [2018-11-23 12:09:52,718 INFO L273 TraceCheckUtils]: 39: Hoare triple {4118#false} assume 0 == ~cond; {4118#false} is VALID [2018-11-23 12:09:52,718 INFO L273 TraceCheckUtils]: 40: Hoare triple {4118#false} assume !false; {4118#false} is VALID [2018-11-23 12:09:52,719 INFO L134 CoverageAnalysis]: Checked inductivity of 246 backedges. 0 proven. 231 refuted. 0 times theorem prover too weak. 15 trivial. 0 not checked. [2018-11-23 12:09:52,719 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:52,719 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 14 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 14 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:52,729 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:52,765 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:52,793 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:52,794 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:52,954 INFO L256 TraceCheckUtils]: 0: Hoare triple {4117#true} call ULTIMATE.init(); {4117#true} is VALID [2018-11-23 12:09:52,954 INFO L273 TraceCheckUtils]: 1: Hoare triple {4117#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {4117#true} is VALID [2018-11-23 12:09:52,955 INFO L273 TraceCheckUtils]: 2: Hoare triple {4117#true} assume true; {4117#true} is VALID [2018-11-23 12:09:52,955 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {4117#true} {4117#true} #60#return; {4117#true} is VALID [2018-11-23 12:09:52,955 INFO L256 TraceCheckUtils]: 4: Hoare triple {4117#true} call #t~ret4 := main(); {4117#true} is VALID [2018-11-23 12:09:52,956 INFO L273 TraceCheckUtils]: 5: Hoare triple {4117#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {4159#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:52,957 INFO L273 TraceCheckUtils]: 6: Hoare triple {4159#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4120#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:52,957 INFO L273 TraceCheckUtils]: 7: Hoare triple {4120#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4121#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:52,958 INFO L273 TraceCheckUtils]: 8: Hoare triple {4121#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4122#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:52,959 INFO L273 TraceCheckUtils]: 9: Hoare triple {4122#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4123#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:52,960 INFO L273 TraceCheckUtils]: 10: Hoare triple {4123#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4124#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:52,961 INFO L273 TraceCheckUtils]: 11: Hoare triple {4124#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4125#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:52,962 INFO L273 TraceCheckUtils]: 12: Hoare triple {4125#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4126#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:52,963 INFO L273 TraceCheckUtils]: 13: Hoare triple {4126#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4127#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:52,964 INFO L273 TraceCheckUtils]: 14: Hoare triple {4127#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4128#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:52,965 INFO L273 TraceCheckUtils]: 15: Hoare triple {4128#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4129#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:52,966 INFO L273 TraceCheckUtils]: 16: Hoare triple {4129#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4130#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:52,967 INFO L273 TraceCheckUtils]: 17: Hoare triple {4130#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4131#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:52,968 INFO L273 TraceCheckUtils]: 18: Hoare triple {4131#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4132#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:52,969 INFO L273 TraceCheckUtils]: 19: Hoare triple {4132#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4133#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:52,970 INFO L273 TraceCheckUtils]: 20: Hoare triple {4133#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4134#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:52,971 INFO L273 TraceCheckUtils]: 21: Hoare triple {4134#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4135#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:52,972 INFO L273 TraceCheckUtils]: 22: Hoare triple {4135#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4136#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:52,973 INFO L273 TraceCheckUtils]: 23: Hoare triple {4136#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4137#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:52,974 INFO L273 TraceCheckUtils]: 24: Hoare triple {4137#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4138#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:52,975 INFO L273 TraceCheckUtils]: 25: Hoare triple {4138#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4139#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:52,976 INFO L273 TraceCheckUtils]: 26: Hoare triple {4139#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4140#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:52,977 INFO L273 TraceCheckUtils]: 27: Hoare triple {4140#(<= main_~i~0 21)} assume !(~i~0 < 100000); {4118#false} is VALID [2018-11-23 12:09:52,977 INFO L273 TraceCheckUtils]: 28: Hoare triple {4118#false} ~i~0 := 1; {4118#false} is VALID [2018-11-23 12:09:52,978 INFO L273 TraceCheckUtils]: 29: Hoare triple {4118#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4118#false} is VALID [2018-11-23 12:09:52,978 INFO L273 TraceCheckUtils]: 30: Hoare triple {4118#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4118#false} is VALID [2018-11-23 12:09:52,978 INFO L273 TraceCheckUtils]: 31: Hoare triple {4118#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4118#false} is VALID [2018-11-23 12:09:52,978 INFO L273 TraceCheckUtils]: 32: Hoare triple {4118#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4118#false} is VALID [2018-11-23 12:09:52,979 INFO L273 TraceCheckUtils]: 33: Hoare triple {4118#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4118#false} is VALID [2018-11-23 12:09:52,979 INFO L273 TraceCheckUtils]: 34: Hoare triple {4118#false} assume !(~i~0 < 100000); {4118#false} is VALID [2018-11-23 12:09:52,979 INFO L273 TraceCheckUtils]: 35: Hoare triple {4118#false} ~i~0 := 1;~j~0 := 0; {4118#false} is VALID [2018-11-23 12:09:52,980 INFO L273 TraceCheckUtils]: 36: Hoare triple {4118#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {4118#false} is VALID [2018-11-23 12:09:52,980 INFO L256 TraceCheckUtils]: 37: Hoare triple {4118#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {4118#false} is VALID [2018-11-23 12:09:52,980 INFO L273 TraceCheckUtils]: 38: Hoare triple {4118#false} ~cond := #in~cond; {4118#false} is VALID [2018-11-23 12:09:52,980 INFO L273 TraceCheckUtils]: 39: Hoare triple {4118#false} assume 0 == ~cond; {4118#false} is VALID [2018-11-23 12:09:52,980 INFO L273 TraceCheckUtils]: 40: Hoare triple {4118#false} assume !false; {4118#false} is VALID [2018-11-23 12:09:52,981 INFO L134 CoverageAnalysis]: Checked inductivity of 246 backedges. 0 proven. 231 refuted. 0 times theorem prover too weak. 15 trivial. 0 not checked. [2018-11-23 12:09:53,002 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:53,003 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [24, 24] total 25 [2018-11-23 12:09:53,003 INFO L78 Accepts]: Start accepts. Automaton has 25 states. Word has length 41 [2018-11-23 12:09:53,003 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:53,003 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 25 states. [2018-11-23 12:09:53,065 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 12:09:53,065 INFO L459 AbstractCegarLoop]: Interpolant automaton has 25 states [2018-11-23 12:09:53,065 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 25 interpolants. [2018-11-23 12:09:53,065 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=300, Invalid=300, Unknown=0, NotChecked=0, Total=600 [2018-11-23 12:09:53,066 INFO L87 Difference]: Start difference. First operand 45 states and 47 transitions. Second operand 25 states. [2018-11-23 12:09:53,877 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:53,877 INFO L93 Difference]: Finished difference Result 72 states and 79 transitions. [2018-11-23 12:09:53,877 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 24 states. [2018-11-23 12:09:53,877 INFO L78 Accepts]: Start accepts. Automaton has 25 states. Word has length 41 [2018-11-23 12:09:53,878 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:53,878 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 25 states. [2018-11-23 12:09:53,880 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 24 states to 24 states and 72 transitions. [2018-11-23 12:09:53,880 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 25 states. [2018-11-23 12:09:53,881 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 24 states to 24 states and 72 transitions. [2018-11-23 12:09:53,882 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 24 states and 72 transitions. [2018-11-23 12:09:54,324 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 72 edges. 72 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:54,326 INFO L225 Difference]: With dead ends: 72 [2018-11-23 12:09:54,326 INFO L226 Difference]: Without dead ends: 55 [2018-11-23 12:09:54,327 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 64 GetRequests, 41 SyntacticMatches, 0 SemanticMatches, 23 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 40 ImplicationChecksByTransitivity, 0.5s TimeCoverageRelationStatistics Valid=300, Invalid=300, Unknown=0, NotChecked=0, Total=600 [2018-11-23 12:09:54,327 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 55 states. [2018-11-23 12:09:54,360 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 55 to 46. [2018-11-23 12:09:54,360 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:54,360 INFO L82 GeneralOperation]: Start isEquivalent. First operand 55 states. Second operand 46 states. [2018-11-23 12:09:54,360 INFO L74 IsIncluded]: Start isIncluded. First operand 55 states. Second operand 46 states. [2018-11-23 12:09:54,361 INFO L87 Difference]: Start difference. First operand 55 states. Second operand 46 states. [2018-11-23 12:09:54,362 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:54,362 INFO L93 Difference]: Finished difference Result 55 states and 60 transitions. [2018-11-23 12:09:54,362 INFO L276 IsEmpty]: Start isEmpty. Operand 55 states and 60 transitions. [2018-11-23 12:09:54,363 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:54,363 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:54,363 INFO L74 IsIncluded]: Start isIncluded. First operand 46 states. Second operand 55 states. [2018-11-23 12:09:54,363 INFO L87 Difference]: Start difference. First operand 46 states. Second operand 55 states. [2018-11-23 12:09:54,364 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:54,365 INFO L93 Difference]: Finished difference Result 55 states and 60 transitions. [2018-11-23 12:09:54,365 INFO L276 IsEmpty]: Start isEmpty. Operand 55 states and 60 transitions. [2018-11-23 12:09:54,365 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:54,365 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:54,365 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:54,366 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:54,366 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 46 states. [2018-11-23 12:09:54,367 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 46 states to 46 states and 48 transitions. [2018-11-23 12:09:54,367 INFO L78 Accepts]: Start accepts. Automaton has 46 states and 48 transitions. Word has length 41 [2018-11-23 12:09:54,367 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:54,367 INFO L480 AbstractCegarLoop]: Abstraction has 46 states and 48 transitions. [2018-11-23 12:09:54,367 INFO L481 AbstractCegarLoop]: Interpolant automaton has 25 states. [2018-11-23 12:09:54,367 INFO L276 IsEmpty]: Start isEmpty. Operand 46 states and 48 transitions. [2018-11-23 12:09:54,368 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 43 [2018-11-23 12:09:54,368 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:54,368 INFO L402 BasicCegarLoop]: trace histogram [22, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:54,368 INFO L423 AbstractCegarLoop]: === Iteration 17 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:54,368 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:54,369 INFO L82 PathProgramCache]: Analyzing trace with hash 756152617, now seen corresponding path program 14 times [2018-11-23 12:09:54,369 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:54,369 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:54,369 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:54,370 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:54,370 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:54,388 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:54,935 INFO L256 TraceCheckUtils]: 0: Hoare triple {4579#true} call ULTIMATE.init(); {4579#true} is VALID [2018-11-23 12:09:54,936 INFO L273 TraceCheckUtils]: 1: Hoare triple {4579#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {4579#true} is VALID [2018-11-23 12:09:54,936 INFO L273 TraceCheckUtils]: 2: Hoare triple {4579#true} assume true; {4579#true} is VALID [2018-11-23 12:09:54,936 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {4579#true} {4579#true} #60#return; {4579#true} is VALID [2018-11-23 12:09:54,936 INFO L256 TraceCheckUtils]: 4: Hoare triple {4579#true} call #t~ret4 := main(); {4579#true} is VALID [2018-11-23 12:09:54,940 INFO L273 TraceCheckUtils]: 5: Hoare triple {4579#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {4581#(= main_~i~0 0)} is VALID [2018-11-23 12:09:54,941 INFO L273 TraceCheckUtils]: 6: Hoare triple {4581#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4582#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:54,942 INFO L273 TraceCheckUtils]: 7: Hoare triple {4582#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4583#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:54,943 INFO L273 TraceCheckUtils]: 8: Hoare triple {4583#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4584#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:54,943 INFO L273 TraceCheckUtils]: 9: Hoare triple {4584#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4585#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:54,944 INFO L273 TraceCheckUtils]: 10: Hoare triple {4585#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4586#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:54,945 INFO L273 TraceCheckUtils]: 11: Hoare triple {4586#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4587#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:54,946 INFO L273 TraceCheckUtils]: 12: Hoare triple {4587#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4588#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:54,947 INFO L273 TraceCheckUtils]: 13: Hoare triple {4588#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4589#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:54,948 INFO L273 TraceCheckUtils]: 14: Hoare triple {4589#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4590#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:54,949 INFO L273 TraceCheckUtils]: 15: Hoare triple {4590#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4591#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:54,950 INFO L273 TraceCheckUtils]: 16: Hoare triple {4591#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4592#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:54,951 INFO L273 TraceCheckUtils]: 17: Hoare triple {4592#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4593#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:54,952 INFO L273 TraceCheckUtils]: 18: Hoare triple {4593#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4594#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:54,972 INFO L273 TraceCheckUtils]: 19: Hoare triple {4594#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4595#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:54,985 INFO L273 TraceCheckUtils]: 20: Hoare triple {4595#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4596#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:54,994 INFO L273 TraceCheckUtils]: 21: Hoare triple {4596#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4597#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:55,008 INFO L273 TraceCheckUtils]: 22: Hoare triple {4597#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4598#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:55,017 INFO L273 TraceCheckUtils]: 23: Hoare triple {4598#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4599#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:55,032 INFO L273 TraceCheckUtils]: 24: Hoare triple {4599#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4600#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:55,041 INFO L273 TraceCheckUtils]: 25: Hoare triple {4600#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4601#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:55,057 INFO L273 TraceCheckUtils]: 26: Hoare triple {4601#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4602#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:55,062 INFO L273 TraceCheckUtils]: 27: Hoare triple {4602#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4603#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:55,063 INFO L273 TraceCheckUtils]: 28: Hoare triple {4603#(<= main_~i~0 22)} assume !(~i~0 < 100000); {4580#false} is VALID [2018-11-23 12:09:55,063 INFO L273 TraceCheckUtils]: 29: Hoare triple {4580#false} ~i~0 := 1; {4580#false} is VALID [2018-11-23 12:09:55,063 INFO L273 TraceCheckUtils]: 30: Hoare triple {4580#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4580#false} is VALID [2018-11-23 12:09:55,063 INFO L273 TraceCheckUtils]: 31: Hoare triple {4580#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4580#false} is VALID [2018-11-23 12:09:55,063 INFO L273 TraceCheckUtils]: 32: Hoare triple {4580#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4580#false} is VALID [2018-11-23 12:09:55,063 INFO L273 TraceCheckUtils]: 33: Hoare triple {4580#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4580#false} is VALID [2018-11-23 12:09:55,063 INFO L273 TraceCheckUtils]: 34: Hoare triple {4580#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4580#false} is VALID [2018-11-23 12:09:55,063 INFO L273 TraceCheckUtils]: 35: Hoare triple {4580#false} assume !(~i~0 < 100000); {4580#false} is VALID [2018-11-23 12:09:55,064 INFO L273 TraceCheckUtils]: 36: Hoare triple {4580#false} ~i~0 := 1;~j~0 := 0; {4580#false} is VALID [2018-11-23 12:09:55,064 INFO L273 TraceCheckUtils]: 37: Hoare triple {4580#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {4580#false} is VALID [2018-11-23 12:09:55,064 INFO L256 TraceCheckUtils]: 38: Hoare triple {4580#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {4580#false} is VALID [2018-11-23 12:09:55,064 INFO L273 TraceCheckUtils]: 39: Hoare triple {4580#false} ~cond := #in~cond; {4580#false} is VALID [2018-11-23 12:09:55,064 INFO L273 TraceCheckUtils]: 40: Hoare triple {4580#false} assume 0 == ~cond; {4580#false} is VALID [2018-11-23 12:09:55,064 INFO L273 TraceCheckUtils]: 41: Hoare triple {4580#false} assume !false; {4580#false} is VALID [2018-11-23 12:09:55,065 INFO L134 CoverageAnalysis]: Checked inductivity of 268 backedges. 0 proven. 253 refuted. 0 times theorem prover too weak. 15 trivial. 0 not checked. [2018-11-23 12:09:55,066 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:55,066 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 15 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 15 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:55,078 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:09:55,115 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:09:55,115 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:55,135 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:55,137 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:55,305 INFO L256 TraceCheckUtils]: 0: Hoare triple {4579#true} call ULTIMATE.init(); {4579#true} is VALID [2018-11-23 12:09:55,305 INFO L273 TraceCheckUtils]: 1: Hoare triple {4579#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {4579#true} is VALID [2018-11-23 12:09:55,305 INFO L273 TraceCheckUtils]: 2: Hoare triple {4579#true} assume true; {4579#true} is VALID [2018-11-23 12:09:55,305 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {4579#true} {4579#true} #60#return; {4579#true} is VALID [2018-11-23 12:09:55,305 INFO L256 TraceCheckUtils]: 4: Hoare triple {4579#true} call #t~ret4 := main(); {4579#true} is VALID [2018-11-23 12:09:55,307 INFO L273 TraceCheckUtils]: 5: Hoare triple {4579#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {4622#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:55,309 INFO L273 TraceCheckUtils]: 6: Hoare triple {4622#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4582#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:55,309 INFO L273 TraceCheckUtils]: 7: Hoare triple {4582#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4583#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:55,310 INFO L273 TraceCheckUtils]: 8: Hoare triple {4583#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4584#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:55,310 INFO L273 TraceCheckUtils]: 9: Hoare triple {4584#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4585#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:55,311 INFO L273 TraceCheckUtils]: 10: Hoare triple {4585#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4586#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:55,312 INFO L273 TraceCheckUtils]: 11: Hoare triple {4586#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4587#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:55,312 INFO L273 TraceCheckUtils]: 12: Hoare triple {4587#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4588#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:55,313 INFO L273 TraceCheckUtils]: 13: Hoare triple {4588#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4589#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:55,314 INFO L273 TraceCheckUtils]: 14: Hoare triple {4589#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4590#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:55,315 INFO L273 TraceCheckUtils]: 15: Hoare triple {4590#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4591#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:55,316 INFO L273 TraceCheckUtils]: 16: Hoare triple {4591#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4592#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:55,317 INFO L273 TraceCheckUtils]: 17: Hoare triple {4592#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4593#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:55,318 INFO L273 TraceCheckUtils]: 18: Hoare triple {4593#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4594#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:55,319 INFO L273 TraceCheckUtils]: 19: Hoare triple {4594#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4595#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:55,320 INFO L273 TraceCheckUtils]: 20: Hoare triple {4595#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4596#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:55,321 INFO L273 TraceCheckUtils]: 21: Hoare triple {4596#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4597#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:55,322 INFO L273 TraceCheckUtils]: 22: Hoare triple {4597#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4598#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:55,323 INFO L273 TraceCheckUtils]: 23: Hoare triple {4598#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4599#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:55,324 INFO L273 TraceCheckUtils]: 24: Hoare triple {4599#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4600#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:55,325 INFO L273 TraceCheckUtils]: 25: Hoare triple {4600#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4601#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:55,326 INFO L273 TraceCheckUtils]: 26: Hoare triple {4601#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4602#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:55,327 INFO L273 TraceCheckUtils]: 27: Hoare triple {4602#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {4603#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:55,328 INFO L273 TraceCheckUtils]: 28: Hoare triple {4603#(<= main_~i~0 22)} assume !(~i~0 < 100000); {4580#false} is VALID [2018-11-23 12:09:55,328 INFO L273 TraceCheckUtils]: 29: Hoare triple {4580#false} ~i~0 := 1; {4580#false} is VALID [2018-11-23 12:09:55,328 INFO L273 TraceCheckUtils]: 30: Hoare triple {4580#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4580#false} is VALID [2018-11-23 12:09:55,329 INFO L273 TraceCheckUtils]: 31: Hoare triple {4580#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4580#false} is VALID [2018-11-23 12:09:55,329 INFO L273 TraceCheckUtils]: 32: Hoare triple {4580#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4580#false} is VALID [2018-11-23 12:09:55,329 INFO L273 TraceCheckUtils]: 33: Hoare triple {4580#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4580#false} is VALID [2018-11-23 12:09:55,329 INFO L273 TraceCheckUtils]: 34: Hoare triple {4580#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {4580#false} is VALID [2018-11-23 12:09:55,329 INFO L273 TraceCheckUtils]: 35: Hoare triple {4580#false} assume !(~i~0 < 100000); {4580#false} is VALID [2018-11-23 12:09:55,330 INFO L273 TraceCheckUtils]: 36: Hoare triple {4580#false} ~i~0 := 1;~j~0 := 0; {4580#false} is VALID [2018-11-23 12:09:55,330 INFO L273 TraceCheckUtils]: 37: Hoare triple {4580#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {4580#false} is VALID [2018-11-23 12:09:55,330 INFO L256 TraceCheckUtils]: 38: Hoare triple {4580#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {4580#false} is VALID [2018-11-23 12:09:55,330 INFO L273 TraceCheckUtils]: 39: Hoare triple {4580#false} ~cond := #in~cond; {4580#false} is VALID [2018-11-23 12:09:55,330 INFO L273 TraceCheckUtils]: 40: Hoare triple {4580#false} assume 0 == ~cond; {4580#false} is VALID [2018-11-23 12:09:55,331 INFO L273 TraceCheckUtils]: 41: Hoare triple {4580#false} assume !false; {4580#false} is VALID [2018-11-23 12:09:55,332 INFO L134 CoverageAnalysis]: Checked inductivity of 268 backedges. 0 proven. 253 refuted. 0 times theorem prover too weak. 15 trivial. 0 not checked. [2018-11-23 12:09:55,351 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:55,351 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [25, 25] total 26 [2018-11-23 12:09:55,351 INFO L78 Accepts]: Start accepts. Automaton has 26 states. Word has length 42 [2018-11-23 12:09:55,352 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:55,352 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 26 states. [2018-11-23 12:09:55,384 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 40 edges. 40 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:55,384 INFO L459 AbstractCegarLoop]: Interpolant automaton has 26 states [2018-11-23 12:09:55,385 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 26 interpolants. [2018-11-23 12:09:55,385 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=325, Invalid=325, Unknown=0, NotChecked=0, Total=650 [2018-11-23 12:09:55,386 INFO L87 Difference]: Start difference. First operand 46 states and 48 transitions. Second operand 26 states. [2018-11-23 12:09:56,062 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:56,062 INFO L93 Difference]: Finished difference Result 73 states and 80 transitions. [2018-11-23 12:09:56,062 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 25 states. [2018-11-23 12:09:56,062 INFO L78 Accepts]: Start accepts. Automaton has 26 states. Word has length 42 [2018-11-23 12:09:56,063 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:56,063 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 26 states. [2018-11-23 12:09:56,064 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 25 states to 25 states and 73 transitions. [2018-11-23 12:09:56,065 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 26 states. [2018-11-23 12:09:56,066 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 25 states to 25 states and 73 transitions. [2018-11-23 12:09:56,067 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 25 states and 73 transitions. [2018-11-23 12:09:56,558 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 73 edges. 73 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:56,560 INFO L225 Difference]: With dead ends: 73 [2018-11-23 12:09:56,560 INFO L226 Difference]: Without dead ends: 56 [2018-11-23 12:09:56,561 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 66 GetRequests, 42 SyntacticMatches, 0 SemanticMatches, 24 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 42 ImplicationChecksByTransitivity, 0.3s TimeCoverageRelationStatistics Valid=325, Invalid=325, Unknown=0, NotChecked=0, Total=650 [2018-11-23 12:09:56,562 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 56 states. [2018-11-23 12:09:56,654 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 56 to 47. [2018-11-23 12:09:56,654 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:56,654 INFO L82 GeneralOperation]: Start isEquivalent. First operand 56 states. Second operand 47 states. [2018-11-23 12:09:56,654 INFO L74 IsIncluded]: Start isIncluded. First operand 56 states. Second operand 47 states. [2018-11-23 12:09:56,654 INFO L87 Difference]: Start difference. First operand 56 states. Second operand 47 states. [2018-11-23 12:09:56,657 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:56,657 INFO L93 Difference]: Finished difference Result 56 states and 61 transitions. [2018-11-23 12:09:56,658 INFO L276 IsEmpty]: Start isEmpty. Operand 56 states and 61 transitions. [2018-11-23 12:09:56,658 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:56,658 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:56,658 INFO L74 IsIncluded]: Start isIncluded. First operand 47 states. Second operand 56 states. [2018-11-23 12:09:56,659 INFO L87 Difference]: Start difference. First operand 47 states. Second operand 56 states. [2018-11-23 12:09:56,660 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:56,660 INFO L93 Difference]: Finished difference Result 56 states and 61 transitions. [2018-11-23 12:09:56,661 INFO L276 IsEmpty]: Start isEmpty. Operand 56 states and 61 transitions. [2018-11-23 12:09:56,661 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:56,661 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:56,661 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:56,662 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:56,662 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 47 states. [2018-11-23 12:09:56,663 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 47 states to 47 states and 49 transitions. [2018-11-23 12:09:56,663 INFO L78 Accepts]: Start accepts. Automaton has 47 states and 49 transitions. Word has length 42 [2018-11-23 12:09:56,663 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:56,663 INFO L480 AbstractCegarLoop]: Abstraction has 47 states and 49 transitions. [2018-11-23 12:09:56,663 INFO L481 AbstractCegarLoop]: Interpolant automaton has 26 states. [2018-11-23 12:09:56,664 INFO L276 IsEmpty]: Start isEmpty. Operand 47 states and 49 transitions. [2018-11-23 12:09:56,664 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 44 [2018-11-23 12:09:56,664 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:56,664 INFO L402 BasicCegarLoop]: trace histogram [23, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:56,665 INFO L423 AbstractCegarLoop]: === Iteration 18 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:56,665 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:56,665 INFO L82 PathProgramCache]: Analyzing trace with hash -52818299, now seen corresponding path program 15 times [2018-11-23 12:09:56,665 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:56,665 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:56,666 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:56,666 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:56,666 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:56,688 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:57,407 INFO L256 TraceCheckUtils]: 0: Hoare triple {5051#true} call ULTIMATE.init(); {5051#true} is VALID [2018-11-23 12:09:57,408 INFO L273 TraceCheckUtils]: 1: Hoare triple {5051#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {5051#true} is VALID [2018-11-23 12:09:57,408 INFO L273 TraceCheckUtils]: 2: Hoare triple {5051#true} assume true; {5051#true} is VALID [2018-11-23 12:09:57,408 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {5051#true} {5051#true} #60#return; {5051#true} is VALID [2018-11-23 12:09:57,408 INFO L256 TraceCheckUtils]: 4: Hoare triple {5051#true} call #t~ret4 := main(); {5051#true} is VALID [2018-11-23 12:09:57,413 INFO L273 TraceCheckUtils]: 5: Hoare triple {5051#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {5053#(= main_~i~0 0)} is VALID [2018-11-23 12:09:57,414 INFO L273 TraceCheckUtils]: 6: Hoare triple {5053#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5054#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:57,415 INFO L273 TraceCheckUtils]: 7: Hoare triple {5054#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5055#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:57,415 INFO L273 TraceCheckUtils]: 8: Hoare triple {5055#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5056#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:57,416 INFO L273 TraceCheckUtils]: 9: Hoare triple {5056#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5057#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:57,417 INFO L273 TraceCheckUtils]: 10: Hoare triple {5057#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5058#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:57,418 INFO L273 TraceCheckUtils]: 11: Hoare triple {5058#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5059#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:57,419 INFO L273 TraceCheckUtils]: 12: Hoare triple {5059#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5060#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:57,420 INFO L273 TraceCheckUtils]: 13: Hoare triple {5060#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5061#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:57,421 INFO L273 TraceCheckUtils]: 14: Hoare triple {5061#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5062#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:57,422 INFO L273 TraceCheckUtils]: 15: Hoare triple {5062#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5063#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:57,423 INFO L273 TraceCheckUtils]: 16: Hoare triple {5063#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5064#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:57,424 INFO L273 TraceCheckUtils]: 17: Hoare triple {5064#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5065#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:57,425 INFO L273 TraceCheckUtils]: 18: Hoare triple {5065#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5066#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:57,427 INFO L273 TraceCheckUtils]: 19: Hoare triple {5066#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5067#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:57,428 INFO L273 TraceCheckUtils]: 20: Hoare triple {5067#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5068#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:57,429 INFO L273 TraceCheckUtils]: 21: Hoare triple {5068#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5069#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:57,430 INFO L273 TraceCheckUtils]: 22: Hoare triple {5069#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5070#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:57,431 INFO L273 TraceCheckUtils]: 23: Hoare triple {5070#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5071#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:57,432 INFO L273 TraceCheckUtils]: 24: Hoare triple {5071#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5072#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:57,433 INFO L273 TraceCheckUtils]: 25: Hoare triple {5072#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5073#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:57,434 INFO L273 TraceCheckUtils]: 26: Hoare triple {5073#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5074#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:57,435 INFO L273 TraceCheckUtils]: 27: Hoare triple {5074#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5075#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:57,436 INFO L273 TraceCheckUtils]: 28: Hoare triple {5075#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5076#(<= main_~i~0 23)} is VALID [2018-11-23 12:09:57,436 INFO L273 TraceCheckUtils]: 29: Hoare triple {5076#(<= main_~i~0 23)} assume !(~i~0 < 100000); {5052#false} is VALID [2018-11-23 12:09:57,436 INFO L273 TraceCheckUtils]: 30: Hoare triple {5052#false} ~i~0 := 1; {5052#false} is VALID [2018-11-23 12:09:57,437 INFO L273 TraceCheckUtils]: 31: Hoare triple {5052#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5052#false} is VALID [2018-11-23 12:09:57,437 INFO L273 TraceCheckUtils]: 32: Hoare triple {5052#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5052#false} is VALID [2018-11-23 12:09:57,437 INFO L273 TraceCheckUtils]: 33: Hoare triple {5052#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5052#false} is VALID [2018-11-23 12:09:57,437 INFO L273 TraceCheckUtils]: 34: Hoare triple {5052#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5052#false} is VALID [2018-11-23 12:09:57,437 INFO L273 TraceCheckUtils]: 35: Hoare triple {5052#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5052#false} is VALID [2018-11-23 12:09:57,438 INFO L273 TraceCheckUtils]: 36: Hoare triple {5052#false} assume !(~i~0 < 100000); {5052#false} is VALID [2018-11-23 12:09:57,438 INFO L273 TraceCheckUtils]: 37: Hoare triple {5052#false} ~i~0 := 1;~j~0 := 0; {5052#false} is VALID [2018-11-23 12:09:57,438 INFO L273 TraceCheckUtils]: 38: Hoare triple {5052#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {5052#false} is VALID [2018-11-23 12:09:57,438 INFO L256 TraceCheckUtils]: 39: Hoare triple {5052#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {5052#false} is VALID [2018-11-23 12:09:57,438 INFO L273 TraceCheckUtils]: 40: Hoare triple {5052#false} ~cond := #in~cond; {5052#false} is VALID [2018-11-23 12:09:57,439 INFO L273 TraceCheckUtils]: 41: Hoare triple {5052#false} assume 0 == ~cond; {5052#false} is VALID [2018-11-23 12:09:57,439 INFO L273 TraceCheckUtils]: 42: Hoare triple {5052#false} assume !false; {5052#false} is VALID [2018-11-23 12:09:57,440 INFO L134 CoverageAnalysis]: Checked inductivity of 291 backedges. 0 proven. 276 refuted. 0 times theorem prover too weak. 15 trivial. 0 not checked. [2018-11-23 12:09:57,440 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:57,440 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 16 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 16 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:57,449 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:09:57,494 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 4 check-sat command(s) [2018-11-23 12:09:57,495 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:57,508 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:57,509 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:57,697 INFO L256 TraceCheckUtils]: 0: Hoare triple {5051#true} call ULTIMATE.init(); {5051#true} is VALID [2018-11-23 12:09:57,697 INFO L273 TraceCheckUtils]: 1: Hoare triple {5051#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {5051#true} is VALID [2018-11-23 12:09:57,697 INFO L273 TraceCheckUtils]: 2: Hoare triple {5051#true} assume true; {5051#true} is VALID [2018-11-23 12:09:57,697 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {5051#true} {5051#true} #60#return; {5051#true} is VALID [2018-11-23 12:09:57,698 INFO L256 TraceCheckUtils]: 4: Hoare triple {5051#true} call #t~ret4 := main(); {5051#true} is VALID [2018-11-23 12:09:57,698 INFO L273 TraceCheckUtils]: 5: Hoare triple {5051#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {5051#true} is VALID [2018-11-23 12:09:57,698 INFO L273 TraceCheckUtils]: 6: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,698 INFO L273 TraceCheckUtils]: 7: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,698 INFO L273 TraceCheckUtils]: 8: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,699 INFO L273 TraceCheckUtils]: 9: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,699 INFO L273 TraceCheckUtils]: 10: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,699 INFO L273 TraceCheckUtils]: 11: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,699 INFO L273 TraceCheckUtils]: 12: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,699 INFO L273 TraceCheckUtils]: 13: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,700 INFO L273 TraceCheckUtils]: 14: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,700 INFO L273 TraceCheckUtils]: 15: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,700 INFO L273 TraceCheckUtils]: 16: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,700 INFO L273 TraceCheckUtils]: 17: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,700 INFO L273 TraceCheckUtils]: 18: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,700 INFO L273 TraceCheckUtils]: 19: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,700 INFO L273 TraceCheckUtils]: 20: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,701 INFO L273 TraceCheckUtils]: 21: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,701 INFO L273 TraceCheckUtils]: 22: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,701 INFO L273 TraceCheckUtils]: 23: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,701 INFO L273 TraceCheckUtils]: 24: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,701 INFO L273 TraceCheckUtils]: 25: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,701 INFO L273 TraceCheckUtils]: 26: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,701 INFO L273 TraceCheckUtils]: 27: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,701 INFO L273 TraceCheckUtils]: 28: Hoare triple {5051#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5051#true} is VALID [2018-11-23 12:09:57,701 INFO L273 TraceCheckUtils]: 29: Hoare triple {5051#true} assume !(~i~0 < 100000); {5051#true} is VALID [2018-11-23 12:09:57,702 INFO L273 TraceCheckUtils]: 30: Hoare triple {5051#true} ~i~0 := 1; {5054#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:57,703 INFO L273 TraceCheckUtils]: 31: Hoare triple {5054#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5063#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:57,703 INFO L273 TraceCheckUtils]: 32: Hoare triple {5063#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5072#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:57,704 INFO L273 TraceCheckUtils]: 33: Hoare triple {5072#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5179#(<= main_~i~0 28)} is VALID [2018-11-23 12:09:57,704 INFO L273 TraceCheckUtils]: 34: Hoare triple {5179#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5183#(<= main_~i~0 37)} is VALID [2018-11-23 12:09:57,705 INFO L273 TraceCheckUtils]: 35: Hoare triple {5183#(<= main_~i~0 37)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5187#(<= main_~i~0 46)} is VALID [2018-11-23 12:09:57,706 INFO L273 TraceCheckUtils]: 36: Hoare triple {5187#(<= main_~i~0 46)} assume !(~i~0 < 100000); {5052#false} is VALID [2018-11-23 12:09:57,706 INFO L273 TraceCheckUtils]: 37: Hoare triple {5052#false} ~i~0 := 1;~j~0 := 0; {5052#false} is VALID [2018-11-23 12:09:57,706 INFO L273 TraceCheckUtils]: 38: Hoare triple {5052#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {5052#false} is VALID [2018-11-23 12:09:57,706 INFO L256 TraceCheckUtils]: 39: Hoare triple {5052#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {5052#false} is VALID [2018-11-23 12:09:57,706 INFO L273 TraceCheckUtils]: 40: Hoare triple {5052#false} ~cond := #in~cond; {5052#false} is VALID [2018-11-23 12:09:57,707 INFO L273 TraceCheckUtils]: 41: Hoare triple {5052#false} assume 0 == ~cond; {5052#false} is VALID [2018-11-23 12:09:57,707 INFO L273 TraceCheckUtils]: 42: Hoare triple {5052#false} assume !false; {5052#false} is VALID [2018-11-23 12:09:57,708 INFO L134 CoverageAnalysis]: Checked inductivity of 291 backedges. 0 proven. 15 refuted. 0 times theorem prover too weak. 276 trivial. 0 not checked. [2018-11-23 12:09:57,731 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:57,731 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [26, 8] total 29 [2018-11-23 12:09:57,731 INFO L78 Accepts]: Start accepts. Automaton has 29 states. Word has length 43 [2018-11-23 12:09:57,731 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:57,731 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 29 states. [2018-11-23 12:09:57,774 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 49 edges. 49 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:57,774 INFO L459 AbstractCegarLoop]: Interpolant automaton has 29 states [2018-11-23 12:09:57,774 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 29 interpolants. [2018-11-23 12:09:57,775 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=406, Invalid=406, Unknown=0, NotChecked=0, Total=812 [2018-11-23 12:09:57,775 INFO L87 Difference]: Start difference. First operand 47 states and 49 transitions. Second operand 29 states. [2018-11-23 12:09:58,726 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:58,726 INFO L93 Difference]: Finished difference Result 87 states and 101 transitions. [2018-11-23 12:09:58,726 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 29 states. [2018-11-23 12:09:58,727 INFO L78 Accepts]: Start accepts. Automaton has 29 states. Word has length 43 [2018-11-23 12:09:58,727 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:58,727 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 29 states. [2018-11-23 12:09:58,729 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 29 states to 29 states and 96 transitions. [2018-11-23 12:09:58,729 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 29 states. [2018-11-23 12:09:58,731 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 29 states to 29 states and 96 transitions. [2018-11-23 12:09:58,731 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 29 states and 96 transitions. [2018-11-23 12:09:58,820 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 96 edges. 96 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:58,822 INFO L225 Difference]: With dead ends: 87 [2018-11-23 12:09:58,822 INFO L226 Difference]: Without dead ends: 70 [2018-11-23 12:09:58,823 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 68 GetRequests, 41 SyntacticMatches, 0 SemanticMatches, 27 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.6s TimeCoverageRelationStatistics Valid=406, Invalid=406, Unknown=0, NotChecked=0, Total=812 [2018-11-23 12:09:58,823 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 70 states. [2018-11-23 12:09:58,859 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 70 to 52. [2018-11-23 12:09:58,859 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:58,859 INFO L82 GeneralOperation]: Start isEquivalent. First operand 70 states. Second operand 52 states. [2018-11-23 12:09:58,859 INFO L74 IsIncluded]: Start isIncluded. First operand 70 states. Second operand 52 states. [2018-11-23 12:09:58,859 INFO L87 Difference]: Start difference. First operand 70 states. Second operand 52 states. [2018-11-23 12:09:58,861 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:58,861 INFO L93 Difference]: Finished difference Result 70 states and 78 transitions. [2018-11-23 12:09:58,861 INFO L276 IsEmpty]: Start isEmpty. Operand 70 states and 78 transitions. [2018-11-23 12:09:58,862 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:58,862 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:58,862 INFO L74 IsIncluded]: Start isIncluded. First operand 52 states. Second operand 70 states. [2018-11-23 12:09:58,862 INFO L87 Difference]: Start difference. First operand 52 states. Second operand 70 states. [2018-11-23 12:09:58,863 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:58,864 INFO L93 Difference]: Finished difference Result 70 states and 78 transitions. [2018-11-23 12:09:58,864 INFO L276 IsEmpty]: Start isEmpty. Operand 70 states and 78 transitions. [2018-11-23 12:09:58,864 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:58,864 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:58,864 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:58,865 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:58,865 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 52 states. [2018-11-23 12:09:58,866 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 52 states to 52 states and 54 transitions. [2018-11-23 12:09:58,866 INFO L78 Accepts]: Start accepts. Automaton has 52 states and 54 transitions. Word has length 43 [2018-11-23 12:09:58,866 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:58,866 INFO L480 AbstractCegarLoop]: Abstraction has 52 states and 54 transitions. [2018-11-23 12:09:58,866 INFO L481 AbstractCegarLoop]: Interpolant automaton has 29 states. [2018-11-23 12:09:58,866 INFO L276 IsEmpty]: Start isEmpty. Operand 52 states and 54 transitions. [2018-11-23 12:09:58,867 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 49 [2018-11-23 12:09:58,867 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:58,867 INFO L402 BasicCegarLoop]: trace histogram [27, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:58,867 INFO L423 AbstractCegarLoop]: === Iteration 19 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:58,867 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:58,868 INFO L82 PathProgramCache]: Analyzing trace with hash -67994774, now seen corresponding path program 16 times [2018-11-23 12:09:58,868 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:58,868 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:58,869 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:58,869 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:58,869 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:58,893 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:59,960 INFO L256 TraceCheckUtils]: 0: Hoare triple {5592#true} call ULTIMATE.init(); {5592#true} is VALID [2018-11-23 12:09:59,960 INFO L273 TraceCheckUtils]: 1: Hoare triple {5592#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {5592#true} is VALID [2018-11-23 12:09:59,961 INFO L273 TraceCheckUtils]: 2: Hoare triple {5592#true} assume true; {5592#true} is VALID [2018-11-23 12:09:59,961 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {5592#true} {5592#true} #60#return; {5592#true} is VALID [2018-11-23 12:09:59,961 INFO L256 TraceCheckUtils]: 4: Hoare triple {5592#true} call #t~ret4 := main(); {5592#true} is VALID [2018-11-23 12:09:59,961 INFO L273 TraceCheckUtils]: 5: Hoare triple {5592#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {5594#(= main_~i~0 0)} is VALID [2018-11-23 12:09:59,962 INFO L273 TraceCheckUtils]: 6: Hoare triple {5594#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5595#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:59,963 INFO L273 TraceCheckUtils]: 7: Hoare triple {5595#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5596#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:59,964 INFO L273 TraceCheckUtils]: 8: Hoare triple {5596#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5597#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:59,964 INFO L273 TraceCheckUtils]: 9: Hoare triple {5597#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5598#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:59,965 INFO L273 TraceCheckUtils]: 10: Hoare triple {5598#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5599#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:59,965 INFO L273 TraceCheckUtils]: 11: Hoare triple {5599#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5600#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:59,966 INFO L273 TraceCheckUtils]: 12: Hoare triple {5600#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5601#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:59,967 INFO L273 TraceCheckUtils]: 13: Hoare triple {5601#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5602#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:59,968 INFO L273 TraceCheckUtils]: 14: Hoare triple {5602#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5603#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:59,969 INFO L273 TraceCheckUtils]: 15: Hoare triple {5603#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5604#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:59,970 INFO L273 TraceCheckUtils]: 16: Hoare triple {5604#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5605#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:59,971 INFO L273 TraceCheckUtils]: 17: Hoare triple {5605#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5606#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:59,972 INFO L273 TraceCheckUtils]: 18: Hoare triple {5606#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5607#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:59,973 INFO L273 TraceCheckUtils]: 19: Hoare triple {5607#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5608#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:59,974 INFO L273 TraceCheckUtils]: 20: Hoare triple {5608#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5609#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:59,975 INFO L273 TraceCheckUtils]: 21: Hoare triple {5609#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5610#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:59,976 INFO L273 TraceCheckUtils]: 22: Hoare triple {5610#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5611#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:59,977 INFO L273 TraceCheckUtils]: 23: Hoare triple {5611#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5612#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:59,978 INFO L273 TraceCheckUtils]: 24: Hoare triple {5612#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5613#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:59,979 INFO L273 TraceCheckUtils]: 25: Hoare triple {5613#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5614#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:59,980 INFO L273 TraceCheckUtils]: 26: Hoare triple {5614#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5615#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:59,981 INFO L273 TraceCheckUtils]: 27: Hoare triple {5615#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5616#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:59,982 INFO L273 TraceCheckUtils]: 28: Hoare triple {5616#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5617#(<= main_~i~0 23)} is VALID [2018-11-23 12:09:59,983 INFO L273 TraceCheckUtils]: 29: Hoare triple {5617#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5618#(<= main_~i~0 24)} is VALID [2018-11-23 12:09:59,984 INFO L273 TraceCheckUtils]: 30: Hoare triple {5618#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5619#(<= main_~i~0 25)} is VALID [2018-11-23 12:09:59,984 INFO L273 TraceCheckUtils]: 31: Hoare triple {5619#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5620#(<= main_~i~0 26)} is VALID [2018-11-23 12:09:59,985 INFO L273 TraceCheckUtils]: 32: Hoare triple {5620#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5621#(<= main_~i~0 27)} is VALID [2018-11-23 12:09:59,986 INFO L273 TraceCheckUtils]: 33: Hoare triple {5621#(<= main_~i~0 27)} assume !(~i~0 < 100000); {5593#false} is VALID [2018-11-23 12:09:59,986 INFO L273 TraceCheckUtils]: 34: Hoare triple {5593#false} ~i~0 := 1; {5593#false} is VALID [2018-11-23 12:09:59,987 INFO L273 TraceCheckUtils]: 35: Hoare triple {5593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5593#false} is VALID [2018-11-23 12:09:59,987 INFO L273 TraceCheckUtils]: 36: Hoare triple {5593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5593#false} is VALID [2018-11-23 12:09:59,987 INFO L273 TraceCheckUtils]: 37: Hoare triple {5593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5593#false} is VALID [2018-11-23 12:09:59,987 INFO L273 TraceCheckUtils]: 38: Hoare triple {5593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5593#false} is VALID [2018-11-23 12:09:59,987 INFO L273 TraceCheckUtils]: 39: Hoare triple {5593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5593#false} is VALID [2018-11-23 12:09:59,988 INFO L273 TraceCheckUtils]: 40: Hoare triple {5593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5593#false} is VALID [2018-11-23 12:09:59,988 INFO L273 TraceCheckUtils]: 41: Hoare triple {5593#false} assume !(~i~0 < 100000); {5593#false} is VALID [2018-11-23 12:09:59,988 INFO L273 TraceCheckUtils]: 42: Hoare triple {5593#false} ~i~0 := 1;~j~0 := 0; {5593#false} is VALID [2018-11-23 12:09:59,988 INFO L273 TraceCheckUtils]: 43: Hoare triple {5593#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {5593#false} is VALID [2018-11-23 12:09:59,988 INFO L256 TraceCheckUtils]: 44: Hoare triple {5593#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {5593#false} is VALID [2018-11-23 12:09:59,989 INFO L273 TraceCheckUtils]: 45: Hoare triple {5593#false} ~cond := #in~cond; {5593#false} is VALID [2018-11-23 12:09:59,989 INFO L273 TraceCheckUtils]: 46: Hoare triple {5593#false} assume 0 == ~cond; {5593#false} is VALID [2018-11-23 12:09:59,989 INFO L273 TraceCheckUtils]: 47: Hoare triple {5593#false} assume !false; {5593#false} is VALID [2018-11-23 12:09:59,991 INFO L134 CoverageAnalysis]: Checked inductivity of 399 backedges. 0 proven. 378 refuted. 0 times theorem prover too weak. 21 trivial. 0 not checked. [2018-11-23 12:09:59,991 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:59,991 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 17 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 17 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:00,000 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:10:00,039 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:10:00,039 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:00,056 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:00,057 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:00,297 INFO L256 TraceCheckUtils]: 0: Hoare triple {5592#true} call ULTIMATE.init(); {5592#true} is VALID [2018-11-23 12:10:00,297 INFO L273 TraceCheckUtils]: 1: Hoare triple {5592#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {5592#true} is VALID [2018-11-23 12:10:00,298 INFO L273 TraceCheckUtils]: 2: Hoare triple {5592#true} assume true; {5592#true} is VALID [2018-11-23 12:10:00,298 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {5592#true} {5592#true} #60#return; {5592#true} is VALID [2018-11-23 12:10:00,298 INFO L256 TraceCheckUtils]: 4: Hoare triple {5592#true} call #t~ret4 := main(); {5592#true} is VALID [2018-11-23 12:10:00,299 INFO L273 TraceCheckUtils]: 5: Hoare triple {5592#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {5640#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:00,299 INFO L273 TraceCheckUtils]: 6: Hoare triple {5640#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5595#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:00,300 INFO L273 TraceCheckUtils]: 7: Hoare triple {5595#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5596#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:00,300 INFO L273 TraceCheckUtils]: 8: Hoare triple {5596#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5597#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:00,301 INFO L273 TraceCheckUtils]: 9: Hoare triple {5597#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5598#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:00,302 INFO L273 TraceCheckUtils]: 10: Hoare triple {5598#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5599#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:00,303 INFO L273 TraceCheckUtils]: 11: Hoare triple {5599#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5600#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:00,304 INFO L273 TraceCheckUtils]: 12: Hoare triple {5600#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5601#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:00,305 INFO L273 TraceCheckUtils]: 13: Hoare triple {5601#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5602#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:00,306 INFO L273 TraceCheckUtils]: 14: Hoare triple {5602#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5603#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:00,307 INFO L273 TraceCheckUtils]: 15: Hoare triple {5603#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5604#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:00,308 INFO L273 TraceCheckUtils]: 16: Hoare triple {5604#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5605#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:00,309 INFO L273 TraceCheckUtils]: 17: Hoare triple {5605#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5606#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:00,310 INFO L273 TraceCheckUtils]: 18: Hoare triple {5606#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5607#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:00,311 INFO L273 TraceCheckUtils]: 19: Hoare triple {5607#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5608#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:00,312 INFO L273 TraceCheckUtils]: 20: Hoare triple {5608#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5609#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:00,313 INFO L273 TraceCheckUtils]: 21: Hoare triple {5609#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5610#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:00,314 INFO L273 TraceCheckUtils]: 22: Hoare triple {5610#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5611#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:00,315 INFO L273 TraceCheckUtils]: 23: Hoare triple {5611#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5612#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:00,316 INFO L273 TraceCheckUtils]: 24: Hoare triple {5612#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5613#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:00,316 INFO L273 TraceCheckUtils]: 25: Hoare triple {5613#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5614#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:00,318 INFO L273 TraceCheckUtils]: 26: Hoare triple {5614#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5615#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:00,319 INFO L273 TraceCheckUtils]: 27: Hoare triple {5615#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5616#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:00,320 INFO L273 TraceCheckUtils]: 28: Hoare triple {5616#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5617#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:00,321 INFO L273 TraceCheckUtils]: 29: Hoare triple {5617#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5618#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:00,322 INFO L273 TraceCheckUtils]: 30: Hoare triple {5618#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5619#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:00,323 INFO L273 TraceCheckUtils]: 31: Hoare triple {5619#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5620#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:00,324 INFO L273 TraceCheckUtils]: 32: Hoare triple {5620#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5621#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:00,324 INFO L273 TraceCheckUtils]: 33: Hoare triple {5621#(<= main_~i~0 27)} assume !(~i~0 < 100000); {5593#false} is VALID [2018-11-23 12:10:00,324 INFO L273 TraceCheckUtils]: 34: Hoare triple {5593#false} ~i~0 := 1; {5593#false} is VALID [2018-11-23 12:10:00,325 INFO L273 TraceCheckUtils]: 35: Hoare triple {5593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5593#false} is VALID [2018-11-23 12:10:00,325 INFO L273 TraceCheckUtils]: 36: Hoare triple {5593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5593#false} is VALID [2018-11-23 12:10:00,325 INFO L273 TraceCheckUtils]: 37: Hoare triple {5593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5593#false} is VALID [2018-11-23 12:10:00,325 INFO L273 TraceCheckUtils]: 38: Hoare triple {5593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5593#false} is VALID [2018-11-23 12:10:00,326 INFO L273 TraceCheckUtils]: 39: Hoare triple {5593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5593#false} is VALID [2018-11-23 12:10:00,326 INFO L273 TraceCheckUtils]: 40: Hoare triple {5593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {5593#false} is VALID [2018-11-23 12:10:00,326 INFO L273 TraceCheckUtils]: 41: Hoare triple {5593#false} assume !(~i~0 < 100000); {5593#false} is VALID [2018-11-23 12:10:00,326 INFO L273 TraceCheckUtils]: 42: Hoare triple {5593#false} ~i~0 := 1;~j~0 := 0; {5593#false} is VALID [2018-11-23 12:10:00,326 INFO L273 TraceCheckUtils]: 43: Hoare triple {5593#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {5593#false} is VALID [2018-11-23 12:10:00,327 INFO L256 TraceCheckUtils]: 44: Hoare triple {5593#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {5593#false} is VALID [2018-11-23 12:10:00,327 INFO L273 TraceCheckUtils]: 45: Hoare triple {5593#false} ~cond := #in~cond; {5593#false} is VALID [2018-11-23 12:10:00,327 INFO L273 TraceCheckUtils]: 46: Hoare triple {5593#false} assume 0 == ~cond; {5593#false} is VALID [2018-11-23 12:10:00,327 INFO L273 TraceCheckUtils]: 47: Hoare triple {5593#false} assume !false; {5593#false} is VALID [2018-11-23 12:10:00,329 INFO L134 CoverageAnalysis]: Checked inductivity of 399 backedges. 0 proven. 378 refuted. 0 times theorem prover too weak. 21 trivial. 0 not checked. [2018-11-23 12:10:00,348 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:00,348 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [30, 30] total 31 [2018-11-23 12:10:00,349 INFO L78 Accepts]: Start accepts. Automaton has 31 states. Word has length 48 [2018-11-23 12:10:00,349 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:00,349 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 31 states. [2018-11-23 12:10:00,403 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 45 edges. 45 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:00,403 INFO L459 AbstractCegarLoop]: Interpolant automaton has 31 states [2018-11-23 12:10:00,403 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 31 interpolants. [2018-11-23 12:10:00,404 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=465, Invalid=465, Unknown=0, NotChecked=0, Total=930 [2018-11-23 12:10:00,404 INFO L87 Difference]: Start difference. First operand 52 states and 54 transitions. Second operand 31 states. [2018-11-23 12:10:01,213 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:01,213 INFO L93 Difference]: Finished difference Result 80 states and 87 transitions. [2018-11-23 12:10:01,214 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 30 states. [2018-11-23 12:10:01,214 INFO L78 Accepts]: Start accepts. Automaton has 31 states. Word has length 48 [2018-11-23 12:10:01,214 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:01,214 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 31 states. [2018-11-23 12:10:01,215 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 30 states to 30 states and 78 transitions. [2018-11-23 12:10:01,215 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 31 states. [2018-11-23 12:10:01,216 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 30 states to 30 states and 78 transitions. [2018-11-23 12:10:01,217 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 30 states and 78 transitions. [2018-11-23 12:10:01,782 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 78 edges. 78 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:01,784 INFO L225 Difference]: With dead ends: 80 [2018-11-23 12:10:01,784 INFO L226 Difference]: Without dead ends: 62 [2018-11-23 12:10:01,785 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 77 GetRequests, 48 SyntacticMatches, 0 SemanticMatches, 29 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 52 ImplicationChecksByTransitivity, 0.8s TimeCoverageRelationStatistics Valid=465, Invalid=465, Unknown=0, NotChecked=0, Total=930 [2018-11-23 12:10:01,785 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 62 states. [2018-11-23 12:10:01,825 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 62 to 53. [2018-11-23 12:10:01,826 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:01,826 INFO L82 GeneralOperation]: Start isEquivalent. First operand 62 states. Second operand 53 states. [2018-11-23 12:10:01,826 INFO L74 IsIncluded]: Start isIncluded. First operand 62 states. Second operand 53 states. [2018-11-23 12:10:01,826 INFO L87 Difference]: Start difference. First operand 62 states. Second operand 53 states. [2018-11-23 12:10:01,828 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:01,829 INFO L93 Difference]: Finished difference Result 62 states and 67 transitions. [2018-11-23 12:10:01,829 INFO L276 IsEmpty]: Start isEmpty. Operand 62 states and 67 transitions. [2018-11-23 12:10:01,829 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:01,829 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:01,829 INFO L74 IsIncluded]: Start isIncluded. First operand 53 states. Second operand 62 states. [2018-11-23 12:10:01,830 INFO L87 Difference]: Start difference. First operand 53 states. Second operand 62 states. [2018-11-23 12:10:01,831 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:01,831 INFO L93 Difference]: Finished difference Result 62 states and 67 transitions. [2018-11-23 12:10:01,831 INFO L276 IsEmpty]: Start isEmpty. Operand 62 states and 67 transitions. [2018-11-23 12:10:01,832 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:01,832 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:01,832 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:01,832 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:01,832 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 53 states. [2018-11-23 12:10:01,833 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 53 states to 53 states and 55 transitions. [2018-11-23 12:10:01,833 INFO L78 Accepts]: Start accepts. Automaton has 53 states and 55 transitions. Word has length 48 [2018-11-23 12:10:01,833 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:01,834 INFO L480 AbstractCegarLoop]: Abstraction has 53 states and 55 transitions. [2018-11-23 12:10:01,834 INFO L481 AbstractCegarLoop]: Interpolant automaton has 31 states. [2018-11-23 12:10:01,834 INFO L276 IsEmpty]: Start isEmpty. Operand 53 states and 55 transitions. [2018-11-23 12:10:01,834 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 50 [2018-11-23 12:10:01,834 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:01,834 INFO L402 BasicCegarLoop]: trace histogram [28, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:01,835 INFO L423 AbstractCegarLoop]: === Iteration 20 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:01,835 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:01,835 INFO L82 PathProgramCache]: Analyzing trace with hash -1152115770, now seen corresponding path program 17 times [2018-11-23 12:10:01,835 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:01,835 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:01,836 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:01,836 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:01,836 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:01,861 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:04,563 INFO L256 TraceCheckUtils]: 0: Hoare triple {6125#true} call ULTIMATE.init(); {6125#true} is VALID [2018-11-23 12:10:04,563 INFO L273 TraceCheckUtils]: 1: Hoare triple {6125#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {6125#true} is VALID [2018-11-23 12:10:04,564 INFO L273 TraceCheckUtils]: 2: Hoare triple {6125#true} assume true; {6125#true} is VALID [2018-11-23 12:10:04,564 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {6125#true} {6125#true} #60#return; {6125#true} is VALID [2018-11-23 12:10:04,564 INFO L256 TraceCheckUtils]: 4: Hoare triple {6125#true} call #t~ret4 := main(); {6125#true} is VALID [2018-11-23 12:10:04,565 INFO L273 TraceCheckUtils]: 5: Hoare triple {6125#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {6127#(= main_~i~0 0)} is VALID [2018-11-23 12:10:04,565 INFO L273 TraceCheckUtils]: 6: Hoare triple {6127#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6128#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:04,566 INFO L273 TraceCheckUtils]: 7: Hoare triple {6128#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6129#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:04,567 INFO L273 TraceCheckUtils]: 8: Hoare triple {6129#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6130#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:04,567 INFO L273 TraceCheckUtils]: 9: Hoare triple {6130#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6131#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:04,568 INFO L273 TraceCheckUtils]: 10: Hoare triple {6131#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6132#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:04,569 INFO L273 TraceCheckUtils]: 11: Hoare triple {6132#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6133#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:04,570 INFO L273 TraceCheckUtils]: 12: Hoare triple {6133#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6134#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:04,571 INFO L273 TraceCheckUtils]: 13: Hoare triple {6134#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6135#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:04,572 INFO L273 TraceCheckUtils]: 14: Hoare triple {6135#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6136#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:04,573 INFO L273 TraceCheckUtils]: 15: Hoare triple {6136#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6137#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:04,574 INFO L273 TraceCheckUtils]: 16: Hoare triple {6137#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6138#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:04,575 INFO L273 TraceCheckUtils]: 17: Hoare triple {6138#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6139#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:04,576 INFO L273 TraceCheckUtils]: 18: Hoare triple {6139#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6140#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:04,577 INFO L273 TraceCheckUtils]: 19: Hoare triple {6140#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6141#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:04,578 INFO L273 TraceCheckUtils]: 20: Hoare triple {6141#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6142#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:04,579 INFO L273 TraceCheckUtils]: 21: Hoare triple {6142#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6143#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:04,580 INFO L273 TraceCheckUtils]: 22: Hoare triple {6143#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6144#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:04,581 INFO L273 TraceCheckUtils]: 23: Hoare triple {6144#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6145#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:04,581 INFO L273 TraceCheckUtils]: 24: Hoare triple {6145#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6146#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:04,582 INFO L273 TraceCheckUtils]: 25: Hoare triple {6146#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6147#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:04,583 INFO L273 TraceCheckUtils]: 26: Hoare triple {6147#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6148#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:04,584 INFO L273 TraceCheckUtils]: 27: Hoare triple {6148#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6149#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:04,585 INFO L273 TraceCheckUtils]: 28: Hoare triple {6149#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6150#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:04,586 INFO L273 TraceCheckUtils]: 29: Hoare triple {6150#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6151#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:04,587 INFO L273 TraceCheckUtils]: 30: Hoare triple {6151#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6152#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:04,588 INFO L273 TraceCheckUtils]: 31: Hoare triple {6152#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6153#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:04,589 INFO L273 TraceCheckUtils]: 32: Hoare triple {6153#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6154#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:04,590 INFO L273 TraceCheckUtils]: 33: Hoare triple {6154#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6155#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:04,590 INFO L273 TraceCheckUtils]: 34: Hoare triple {6155#(<= main_~i~0 28)} assume !(~i~0 < 100000); {6126#false} is VALID [2018-11-23 12:10:04,591 INFO L273 TraceCheckUtils]: 35: Hoare triple {6126#false} ~i~0 := 1; {6126#false} is VALID [2018-11-23 12:10:04,591 INFO L273 TraceCheckUtils]: 36: Hoare triple {6126#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6126#false} is VALID [2018-11-23 12:10:04,591 INFO L273 TraceCheckUtils]: 37: Hoare triple {6126#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6126#false} is VALID [2018-11-23 12:10:04,591 INFO L273 TraceCheckUtils]: 38: Hoare triple {6126#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6126#false} is VALID [2018-11-23 12:10:04,592 INFO L273 TraceCheckUtils]: 39: Hoare triple {6126#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6126#false} is VALID [2018-11-23 12:10:04,592 INFO L273 TraceCheckUtils]: 40: Hoare triple {6126#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6126#false} is VALID [2018-11-23 12:10:04,592 INFO L273 TraceCheckUtils]: 41: Hoare triple {6126#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6126#false} is VALID [2018-11-23 12:10:04,592 INFO L273 TraceCheckUtils]: 42: Hoare triple {6126#false} assume !(~i~0 < 100000); {6126#false} is VALID [2018-11-23 12:10:04,592 INFO L273 TraceCheckUtils]: 43: Hoare triple {6126#false} ~i~0 := 1;~j~0 := 0; {6126#false} is VALID [2018-11-23 12:10:04,593 INFO L273 TraceCheckUtils]: 44: Hoare triple {6126#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {6126#false} is VALID [2018-11-23 12:10:04,593 INFO L256 TraceCheckUtils]: 45: Hoare triple {6126#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {6126#false} is VALID [2018-11-23 12:10:04,593 INFO L273 TraceCheckUtils]: 46: Hoare triple {6126#false} ~cond := #in~cond; {6126#false} is VALID [2018-11-23 12:10:04,593 INFO L273 TraceCheckUtils]: 47: Hoare triple {6126#false} assume 0 == ~cond; {6126#false} is VALID [2018-11-23 12:10:04,593 INFO L273 TraceCheckUtils]: 48: Hoare triple {6126#false} assume !false; {6126#false} is VALID [2018-11-23 12:10:04,596 INFO L134 CoverageAnalysis]: Checked inductivity of 427 backedges. 0 proven. 406 refuted. 0 times theorem prover too weak. 21 trivial. 0 not checked. [2018-11-23 12:10:04,596 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:04,596 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 18 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 18 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:04,607 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:10:13,610 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 15 check-sat command(s) [2018-11-23 12:10:13,611 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:13,633 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:13,635 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:13,967 INFO L256 TraceCheckUtils]: 0: Hoare triple {6125#true} call ULTIMATE.init(); {6125#true} is VALID [2018-11-23 12:10:13,967 INFO L273 TraceCheckUtils]: 1: Hoare triple {6125#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {6125#true} is VALID [2018-11-23 12:10:13,967 INFO L273 TraceCheckUtils]: 2: Hoare triple {6125#true} assume true; {6125#true} is VALID [2018-11-23 12:10:13,968 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {6125#true} {6125#true} #60#return; {6125#true} is VALID [2018-11-23 12:10:13,968 INFO L256 TraceCheckUtils]: 4: Hoare triple {6125#true} call #t~ret4 := main(); {6125#true} is VALID [2018-11-23 12:10:13,969 INFO L273 TraceCheckUtils]: 5: Hoare triple {6125#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {6174#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:13,970 INFO L273 TraceCheckUtils]: 6: Hoare triple {6174#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6128#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:13,971 INFO L273 TraceCheckUtils]: 7: Hoare triple {6128#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6129#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:13,971 INFO L273 TraceCheckUtils]: 8: Hoare triple {6129#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6130#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:13,972 INFO L273 TraceCheckUtils]: 9: Hoare triple {6130#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6131#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:13,972 INFO L273 TraceCheckUtils]: 10: Hoare triple {6131#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6132#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:13,973 INFO L273 TraceCheckUtils]: 11: Hoare triple {6132#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6133#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:13,974 INFO L273 TraceCheckUtils]: 12: Hoare triple {6133#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6134#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:13,975 INFO L273 TraceCheckUtils]: 13: Hoare triple {6134#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6135#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:13,976 INFO L273 TraceCheckUtils]: 14: Hoare triple {6135#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6136#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:13,977 INFO L273 TraceCheckUtils]: 15: Hoare triple {6136#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6137#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:13,978 INFO L273 TraceCheckUtils]: 16: Hoare triple {6137#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6138#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:13,979 INFO L273 TraceCheckUtils]: 17: Hoare triple {6138#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6139#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:13,980 INFO L273 TraceCheckUtils]: 18: Hoare triple {6139#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6140#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:13,981 INFO L273 TraceCheckUtils]: 19: Hoare triple {6140#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6141#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:13,982 INFO L273 TraceCheckUtils]: 20: Hoare triple {6141#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6142#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:13,983 INFO L273 TraceCheckUtils]: 21: Hoare triple {6142#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6143#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:13,984 INFO L273 TraceCheckUtils]: 22: Hoare triple {6143#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6144#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:13,985 INFO L273 TraceCheckUtils]: 23: Hoare triple {6144#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6145#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:13,986 INFO L273 TraceCheckUtils]: 24: Hoare triple {6145#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6146#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:13,987 INFO L273 TraceCheckUtils]: 25: Hoare triple {6146#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6147#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:13,988 INFO L273 TraceCheckUtils]: 26: Hoare triple {6147#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6148#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:13,989 INFO L273 TraceCheckUtils]: 27: Hoare triple {6148#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6149#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:13,990 INFO L273 TraceCheckUtils]: 28: Hoare triple {6149#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6150#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:13,991 INFO L273 TraceCheckUtils]: 29: Hoare triple {6150#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6151#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:13,992 INFO L273 TraceCheckUtils]: 30: Hoare triple {6151#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6152#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:13,993 INFO L273 TraceCheckUtils]: 31: Hoare triple {6152#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6153#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:13,994 INFO L273 TraceCheckUtils]: 32: Hoare triple {6153#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6154#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:13,995 INFO L273 TraceCheckUtils]: 33: Hoare triple {6154#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6155#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:13,996 INFO L273 TraceCheckUtils]: 34: Hoare triple {6155#(<= main_~i~0 28)} assume !(~i~0 < 100000); {6126#false} is VALID [2018-11-23 12:10:13,996 INFO L273 TraceCheckUtils]: 35: Hoare triple {6126#false} ~i~0 := 1; {6126#false} is VALID [2018-11-23 12:10:13,997 INFO L273 TraceCheckUtils]: 36: Hoare triple {6126#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6126#false} is VALID [2018-11-23 12:10:13,997 INFO L273 TraceCheckUtils]: 37: Hoare triple {6126#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6126#false} is VALID [2018-11-23 12:10:13,997 INFO L273 TraceCheckUtils]: 38: Hoare triple {6126#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6126#false} is VALID [2018-11-23 12:10:13,997 INFO L273 TraceCheckUtils]: 39: Hoare triple {6126#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6126#false} is VALID [2018-11-23 12:10:13,997 INFO L273 TraceCheckUtils]: 40: Hoare triple {6126#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6126#false} is VALID [2018-11-23 12:10:13,998 INFO L273 TraceCheckUtils]: 41: Hoare triple {6126#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6126#false} is VALID [2018-11-23 12:10:13,998 INFO L273 TraceCheckUtils]: 42: Hoare triple {6126#false} assume !(~i~0 < 100000); {6126#false} is VALID [2018-11-23 12:10:13,998 INFO L273 TraceCheckUtils]: 43: Hoare triple {6126#false} ~i~0 := 1;~j~0 := 0; {6126#false} is VALID [2018-11-23 12:10:13,998 INFO L273 TraceCheckUtils]: 44: Hoare triple {6126#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {6126#false} is VALID [2018-11-23 12:10:13,998 INFO L256 TraceCheckUtils]: 45: Hoare triple {6126#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {6126#false} is VALID [2018-11-23 12:10:13,999 INFO L273 TraceCheckUtils]: 46: Hoare triple {6126#false} ~cond := #in~cond; {6126#false} is VALID [2018-11-23 12:10:13,999 INFO L273 TraceCheckUtils]: 47: Hoare triple {6126#false} assume 0 == ~cond; {6126#false} is VALID [2018-11-23 12:10:13,999 INFO L273 TraceCheckUtils]: 48: Hoare triple {6126#false} assume !false; {6126#false} is VALID [2018-11-23 12:10:14,002 INFO L134 CoverageAnalysis]: Checked inductivity of 427 backedges. 0 proven. 406 refuted. 0 times theorem prover too weak. 21 trivial. 0 not checked. [2018-11-23 12:10:14,025 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:14,025 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [31, 31] total 32 [2018-11-23 12:10:14,026 INFO L78 Accepts]: Start accepts. Automaton has 32 states. Word has length 49 [2018-11-23 12:10:14,026 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:14,026 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 32 states. [2018-11-23 12:10:14,061 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 46 edges. 46 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:14,061 INFO L459 AbstractCegarLoop]: Interpolant automaton has 32 states [2018-11-23 12:10:14,061 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 32 interpolants. [2018-11-23 12:10:14,062 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=496, Invalid=496, Unknown=0, NotChecked=0, Total=992 [2018-11-23 12:10:14,062 INFO L87 Difference]: Start difference. First operand 53 states and 55 transitions. Second operand 32 states. [2018-11-23 12:10:14,620 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:14,620 INFO L93 Difference]: Finished difference Result 84 states and 92 transitions. [2018-11-23 12:10:14,620 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 31 states. [2018-11-23 12:10:14,620 INFO L78 Accepts]: Start accepts. Automaton has 32 states. Word has length 49 [2018-11-23 12:10:14,620 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:14,621 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 32 states. [2018-11-23 12:10:14,622 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 31 states to 31 states and 84 transitions. [2018-11-23 12:10:14,622 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 32 states. [2018-11-23 12:10:14,623 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 31 states to 31 states and 84 transitions. [2018-11-23 12:10:14,623 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 31 states and 84 transitions. [2018-11-23 12:10:14,726 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 84 edges. 84 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:14,728 INFO L225 Difference]: With dead ends: 84 [2018-11-23 12:10:14,728 INFO L226 Difference]: Without dead ends: 66 [2018-11-23 12:10:14,729 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 79 GetRequests, 49 SyntacticMatches, 0 SemanticMatches, 30 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 54 ImplicationChecksByTransitivity, 2.3s TimeCoverageRelationStatistics Valid=496, Invalid=496, Unknown=0, NotChecked=0, Total=992 [2018-11-23 12:10:14,729 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 66 states. [2018-11-23 12:10:14,873 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 66 to 54. [2018-11-23 12:10:14,873 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:14,874 INFO L82 GeneralOperation]: Start isEquivalent. First operand 66 states. Second operand 54 states. [2018-11-23 12:10:14,874 INFO L74 IsIncluded]: Start isIncluded. First operand 66 states. Second operand 54 states. [2018-11-23 12:10:14,874 INFO L87 Difference]: Start difference. First operand 66 states. Second operand 54 states. [2018-11-23 12:10:14,875 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:14,875 INFO L93 Difference]: Finished difference Result 66 states and 72 transitions. [2018-11-23 12:10:14,875 INFO L276 IsEmpty]: Start isEmpty. Operand 66 states and 72 transitions. [2018-11-23 12:10:14,876 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:14,876 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:14,876 INFO L74 IsIncluded]: Start isIncluded. First operand 54 states. Second operand 66 states. [2018-11-23 12:10:14,876 INFO L87 Difference]: Start difference. First operand 54 states. Second operand 66 states. [2018-11-23 12:10:14,877 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:14,877 INFO L93 Difference]: Finished difference Result 66 states and 72 transitions. [2018-11-23 12:10:14,877 INFO L276 IsEmpty]: Start isEmpty. Operand 66 states and 72 transitions. [2018-11-23 12:10:14,877 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:14,878 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:14,878 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:14,878 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:14,878 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 54 states. [2018-11-23 12:10:14,878 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 54 states to 54 states and 56 transitions. [2018-11-23 12:10:14,878 INFO L78 Accepts]: Start accepts. Automaton has 54 states and 56 transitions. Word has length 49 [2018-11-23 12:10:14,879 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:14,879 INFO L480 AbstractCegarLoop]: Abstraction has 54 states and 56 transitions. [2018-11-23 12:10:14,879 INFO L481 AbstractCegarLoop]: Interpolant automaton has 32 states. [2018-11-23 12:10:14,879 INFO L276 IsEmpty]: Start isEmpty. Operand 54 states and 56 transitions. [2018-11-23 12:10:14,879 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 51 [2018-11-23 12:10:14,879 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:14,879 INFO L402 BasicCegarLoop]: trace histogram [29, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:14,880 INFO L423 AbstractCegarLoop]: === Iteration 21 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:14,880 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:14,880 INFO L82 PathProgramCache]: Analyzing trace with hash -400128278, now seen corresponding path program 18 times [2018-11-23 12:10:14,880 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:14,880 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:14,881 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:14,881 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:14,881 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:14,905 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:16,214 INFO L256 TraceCheckUtils]: 0: Hoare triple {6679#true} call ULTIMATE.init(); {6679#true} is VALID [2018-11-23 12:10:16,215 INFO L273 TraceCheckUtils]: 1: Hoare triple {6679#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {6679#true} is VALID [2018-11-23 12:10:16,215 INFO L273 TraceCheckUtils]: 2: Hoare triple {6679#true} assume true; {6679#true} is VALID [2018-11-23 12:10:16,215 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {6679#true} {6679#true} #60#return; {6679#true} is VALID [2018-11-23 12:10:16,215 INFO L256 TraceCheckUtils]: 4: Hoare triple {6679#true} call #t~ret4 := main(); {6679#true} is VALID [2018-11-23 12:10:16,222 INFO L273 TraceCheckUtils]: 5: Hoare triple {6679#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {6681#(= main_~i~0 0)} is VALID [2018-11-23 12:10:16,223 INFO L273 TraceCheckUtils]: 6: Hoare triple {6681#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6682#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:16,224 INFO L273 TraceCheckUtils]: 7: Hoare triple {6682#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6683#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:16,224 INFO L273 TraceCheckUtils]: 8: Hoare triple {6683#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6684#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:16,225 INFO L273 TraceCheckUtils]: 9: Hoare triple {6684#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6685#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:16,226 INFO L273 TraceCheckUtils]: 10: Hoare triple {6685#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6686#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:16,227 INFO L273 TraceCheckUtils]: 11: Hoare triple {6686#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6687#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:16,228 INFO L273 TraceCheckUtils]: 12: Hoare triple {6687#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6688#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:16,229 INFO L273 TraceCheckUtils]: 13: Hoare triple {6688#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6689#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:16,230 INFO L273 TraceCheckUtils]: 14: Hoare triple {6689#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6690#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:16,231 INFO L273 TraceCheckUtils]: 15: Hoare triple {6690#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6691#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:16,231 INFO L273 TraceCheckUtils]: 16: Hoare triple {6691#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6692#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:16,232 INFO L273 TraceCheckUtils]: 17: Hoare triple {6692#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6693#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:16,233 INFO L273 TraceCheckUtils]: 18: Hoare triple {6693#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6694#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:16,234 INFO L273 TraceCheckUtils]: 19: Hoare triple {6694#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6695#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:16,235 INFO L273 TraceCheckUtils]: 20: Hoare triple {6695#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6696#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:16,236 INFO L273 TraceCheckUtils]: 21: Hoare triple {6696#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6697#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:16,237 INFO L273 TraceCheckUtils]: 22: Hoare triple {6697#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6698#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:16,238 INFO L273 TraceCheckUtils]: 23: Hoare triple {6698#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6699#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:16,239 INFO L273 TraceCheckUtils]: 24: Hoare triple {6699#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6700#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:16,259 INFO L273 TraceCheckUtils]: 25: Hoare triple {6700#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6701#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:16,274 INFO L273 TraceCheckUtils]: 26: Hoare triple {6701#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6702#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:16,279 INFO L273 TraceCheckUtils]: 27: Hoare triple {6702#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6703#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:16,280 INFO L273 TraceCheckUtils]: 28: Hoare triple {6703#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6704#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:16,280 INFO L273 TraceCheckUtils]: 29: Hoare triple {6704#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6705#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:16,281 INFO L273 TraceCheckUtils]: 30: Hoare triple {6705#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6706#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:16,281 INFO L273 TraceCheckUtils]: 31: Hoare triple {6706#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6707#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:16,282 INFO L273 TraceCheckUtils]: 32: Hoare triple {6707#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6708#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:16,283 INFO L273 TraceCheckUtils]: 33: Hoare triple {6708#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6709#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:16,284 INFO L273 TraceCheckUtils]: 34: Hoare triple {6709#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6710#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:16,285 INFO L273 TraceCheckUtils]: 35: Hoare triple {6710#(<= main_~i~0 29)} assume !(~i~0 < 100000); {6680#false} is VALID [2018-11-23 12:10:16,285 INFO L273 TraceCheckUtils]: 36: Hoare triple {6680#false} ~i~0 := 1; {6680#false} is VALID [2018-11-23 12:10:16,285 INFO L273 TraceCheckUtils]: 37: Hoare triple {6680#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6680#false} is VALID [2018-11-23 12:10:16,285 INFO L273 TraceCheckUtils]: 38: Hoare triple {6680#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6680#false} is VALID [2018-11-23 12:10:16,285 INFO L273 TraceCheckUtils]: 39: Hoare triple {6680#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6680#false} is VALID [2018-11-23 12:10:16,286 INFO L273 TraceCheckUtils]: 40: Hoare triple {6680#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6680#false} is VALID [2018-11-23 12:10:16,286 INFO L273 TraceCheckUtils]: 41: Hoare triple {6680#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6680#false} is VALID [2018-11-23 12:10:16,286 INFO L273 TraceCheckUtils]: 42: Hoare triple {6680#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6680#false} is VALID [2018-11-23 12:10:16,286 INFO L273 TraceCheckUtils]: 43: Hoare triple {6680#false} assume !(~i~0 < 100000); {6680#false} is VALID [2018-11-23 12:10:16,286 INFO L273 TraceCheckUtils]: 44: Hoare triple {6680#false} ~i~0 := 1;~j~0 := 0; {6680#false} is VALID [2018-11-23 12:10:16,287 INFO L273 TraceCheckUtils]: 45: Hoare triple {6680#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {6680#false} is VALID [2018-11-23 12:10:16,287 INFO L256 TraceCheckUtils]: 46: Hoare triple {6680#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {6680#false} is VALID [2018-11-23 12:10:16,287 INFO L273 TraceCheckUtils]: 47: Hoare triple {6680#false} ~cond := #in~cond; {6680#false} is VALID [2018-11-23 12:10:16,287 INFO L273 TraceCheckUtils]: 48: Hoare triple {6680#false} assume 0 == ~cond; {6680#false} is VALID [2018-11-23 12:10:16,287 INFO L273 TraceCheckUtils]: 49: Hoare triple {6680#false} assume !false; {6680#false} is VALID [2018-11-23 12:10:16,290 INFO L134 CoverageAnalysis]: Checked inductivity of 456 backedges. 0 proven. 435 refuted. 0 times theorem prover too weak. 21 trivial. 0 not checked. [2018-11-23 12:10:16,290 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:16,290 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 19 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 19 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:16,298 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE [2018-11-23 12:10:16,574 INFO L249 tOrderPrioritization]: Assert order MIX_INSIDE_OUTSIDE issued 7 check-sat command(s) [2018-11-23 12:10:16,574 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:16,586 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:16,588 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:16,811 INFO L256 TraceCheckUtils]: 0: Hoare triple {6679#true} call ULTIMATE.init(); {6679#true} is VALID [2018-11-23 12:10:16,811 INFO L273 TraceCheckUtils]: 1: Hoare triple {6679#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {6679#true} is VALID [2018-11-23 12:10:16,812 INFO L273 TraceCheckUtils]: 2: Hoare triple {6679#true} assume true; {6679#true} is VALID [2018-11-23 12:10:16,812 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {6679#true} {6679#true} #60#return; {6679#true} is VALID [2018-11-23 12:10:16,812 INFO L256 TraceCheckUtils]: 4: Hoare triple {6679#true} call #t~ret4 := main(); {6679#true} is VALID [2018-11-23 12:10:16,812 INFO L273 TraceCheckUtils]: 5: Hoare triple {6679#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {6679#true} is VALID [2018-11-23 12:10:16,812 INFO L273 TraceCheckUtils]: 6: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,813 INFO L273 TraceCheckUtils]: 7: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,813 INFO L273 TraceCheckUtils]: 8: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,813 INFO L273 TraceCheckUtils]: 9: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,813 INFO L273 TraceCheckUtils]: 10: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,813 INFO L273 TraceCheckUtils]: 11: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,813 INFO L273 TraceCheckUtils]: 12: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,813 INFO L273 TraceCheckUtils]: 13: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,814 INFO L273 TraceCheckUtils]: 14: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,814 INFO L273 TraceCheckUtils]: 15: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,814 INFO L273 TraceCheckUtils]: 16: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,814 INFO L273 TraceCheckUtils]: 17: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,814 INFO L273 TraceCheckUtils]: 18: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,814 INFO L273 TraceCheckUtils]: 19: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,814 INFO L273 TraceCheckUtils]: 20: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,814 INFO L273 TraceCheckUtils]: 21: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,814 INFO L273 TraceCheckUtils]: 22: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,815 INFO L273 TraceCheckUtils]: 23: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,815 INFO L273 TraceCheckUtils]: 24: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,815 INFO L273 TraceCheckUtils]: 25: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,815 INFO L273 TraceCheckUtils]: 26: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,815 INFO L273 TraceCheckUtils]: 27: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,815 INFO L273 TraceCheckUtils]: 28: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,815 INFO L273 TraceCheckUtils]: 29: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,815 INFO L273 TraceCheckUtils]: 30: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,816 INFO L273 TraceCheckUtils]: 31: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,816 INFO L273 TraceCheckUtils]: 32: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,816 INFO L273 TraceCheckUtils]: 33: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,816 INFO L273 TraceCheckUtils]: 34: Hoare triple {6679#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6679#true} is VALID [2018-11-23 12:10:16,816 INFO L273 TraceCheckUtils]: 35: Hoare triple {6679#true} assume !(~i~0 < 100000); {6679#true} is VALID [2018-11-23 12:10:16,816 INFO L273 TraceCheckUtils]: 36: Hoare triple {6679#true} ~i~0 := 1; {6682#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:16,817 INFO L273 TraceCheckUtils]: 37: Hoare triple {6682#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6691#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:16,818 INFO L273 TraceCheckUtils]: 38: Hoare triple {6691#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6700#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:16,818 INFO L273 TraceCheckUtils]: 39: Hoare triple {6700#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6709#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:16,819 INFO L273 TraceCheckUtils]: 40: Hoare triple {6709#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6834#(<= main_~i~0 37)} is VALID [2018-11-23 12:10:16,820 INFO L273 TraceCheckUtils]: 41: Hoare triple {6834#(<= main_~i~0 37)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6838#(<= main_~i~0 46)} is VALID [2018-11-23 12:10:16,821 INFO L273 TraceCheckUtils]: 42: Hoare triple {6838#(<= main_~i~0 46)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {6842#(<= main_~i~0 55)} is VALID [2018-11-23 12:10:16,822 INFO L273 TraceCheckUtils]: 43: Hoare triple {6842#(<= main_~i~0 55)} assume !(~i~0 < 100000); {6680#false} is VALID [2018-11-23 12:10:16,822 INFO L273 TraceCheckUtils]: 44: Hoare triple {6680#false} ~i~0 := 1;~j~0 := 0; {6680#false} is VALID [2018-11-23 12:10:16,822 INFO L273 TraceCheckUtils]: 45: Hoare triple {6680#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {6680#false} is VALID [2018-11-23 12:10:16,822 INFO L256 TraceCheckUtils]: 46: Hoare triple {6680#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {6680#false} is VALID [2018-11-23 12:10:16,822 INFO L273 TraceCheckUtils]: 47: Hoare triple {6680#false} ~cond := #in~cond; {6680#false} is VALID [2018-11-23 12:10:16,823 INFO L273 TraceCheckUtils]: 48: Hoare triple {6680#false} assume 0 == ~cond; {6680#false} is VALID [2018-11-23 12:10:16,823 INFO L273 TraceCheckUtils]: 49: Hoare triple {6680#false} assume !false; {6680#false} is VALID [2018-11-23 12:10:16,824 INFO L134 CoverageAnalysis]: Checked inductivity of 456 backedges. 0 proven. 21 refuted. 0 times theorem prover too weak. 435 trivial. 0 not checked. [2018-11-23 12:10:16,844 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:16,845 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [32, 9] total 35 [2018-11-23 12:10:16,845 INFO L78 Accepts]: Start accepts. Automaton has 35 states. Word has length 50 [2018-11-23 12:10:16,845 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:16,845 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 35 states. [2018-11-23 12:10:16,893 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 56 edges. 56 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:16,894 INFO L459 AbstractCegarLoop]: Interpolant automaton has 35 states [2018-11-23 12:10:16,894 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 35 interpolants. [2018-11-23 12:10:16,895 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=595, Invalid=595, Unknown=0, NotChecked=0, Total=1190 [2018-11-23 12:10:16,895 INFO L87 Difference]: Start difference. First operand 54 states and 56 transitions. Second operand 35 states. [2018-11-23 12:10:18,207 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:18,207 INFO L93 Difference]: Finished difference Result 98 states and 113 transitions. [2018-11-23 12:10:18,207 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 35 states. [2018-11-23 12:10:18,207 INFO L78 Accepts]: Start accepts. Automaton has 35 states. Word has length 50 [2018-11-23 12:10:18,208 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:18,208 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 35 states. [2018-11-23 12:10:18,209 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 35 states to 35 states and 107 transitions. [2018-11-23 12:10:18,209 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 35 states. [2018-11-23 12:10:18,211 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 35 states to 35 states and 107 transitions. [2018-11-23 12:10:18,211 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 35 states and 107 transitions. [2018-11-23 12:10:18,377 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 107 edges. 107 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:18,379 INFO L225 Difference]: With dead ends: 98 [2018-11-23 12:10:18,379 INFO L226 Difference]: Without dead ends: 80 [2018-11-23 12:10:18,380 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 81 GetRequests, 48 SyntacticMatches, 0 SemanticMatches, 33 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 1.1s TimeCoverageRelationStatistics Valid=595, Invalid=595, Unknown=0, NotChecked=0, Total=1190 [2018-11-23 12:10:18,380 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 80 states. [2018-11-23 12:10:18,443 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 80 to 59. [2018-11-23 12:10:18,443 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:18,443 INFO L82 GeneralOperation]: Start isEquivalent. First operand 80 states. Second operand 59 states. [2018-11-23 12:10:18,443 INFO L74 IsIncluded]: Start isIncluded. First operand 80 states. Second operand 59 states. [2018-11-23 12:10:18,444 INFO L87 Difference]: Start difference. First operand 80 states. Second operand 59 states. [2018-11-23 12:10:18,446 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:18,446 INFO L93 Difference]: Finished difference Result 80 states and 89 transitions. [2018-11-23 12:10:18,446 INFO L276 IsEmpty]: Start isEmpty. Operand 80 states and 89 transitions. [2018-11-23 12:10:18,447 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:18,447 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:18,447 INFO L74 IsIncluded]: Start isIncluded. First operand 59 states. Second operand 80 states. [2018-11-23 12:10:18,447 INFO L87 Difference]: Start difference. First operand 59 states. Second operand 80 states. [2018-11-23 12:10:18,449 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:18,449 INFO L93 Difference]: Finished difference Result 80 states and 89 transitions. [2018-11-23 12:10:18,449 INFO L276 IsEmpty]: Start isEmpty. Operand 80 states and 89 transitions. [2018-11-23 12:10:18,450 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:18,450 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:18,450 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:18,450 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:18,450 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 59 states. [2018-11-23 12:10:18,451 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 59 states to 59 states and 61 transitions. [2018-11-23 12:10:18,451 INFO L78 Accepts]: Start accepts. Automaton has 59 states and 61 transitions. Word has length 50 [2018-11-23 12:10:18,451 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:18,451 INFO L480 AbstractCegarLoop]: Abstraction has 59 states and 61 transitions. [2018-11-23 12:10:18,451 INFO L481 AbstractCegarLoop]: Interpolant automaton has 35 states. [2018-11-23 12:10:18,452 INFO L276 IsEmpty]: Start isEmpty. Operand 59 states and 61 transitions. [2018-11-23 12:10:18,452 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 56 [2018-11-23 12:10:18,452 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:18,452 INFO L402 BasicCegarLoop]: trace histogram [33, 7, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:18,453 INFO L423 AbstractCegarLoop]: === Iteration 22 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:18,453 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:18,453 INFO L82 PathProgramCache]: Analyzing trace with hash 251380133, now seen corresponding path program 19 times [2018-11-23 12:10:18,453 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:18,453 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:18,454 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:18,454 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:18,454 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:18,483 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:19,349 INFO L256 TraceCheckUtils]: 0: Hoare triple {7302#true} call ULTIMATE.init(); {7302#true} is VALID [2018-11-23 12:10:19,349 INFO L273 TraceCheckUtils]: 1: Hoare triple {7302#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {7302#true} is VALID [2018-11-23 12:10:19,350 INFO L273 TraceCheckUtils]: 2: Hoare triple {7302#true} assume true; {7302#true} is VALID [2018-11-23 12:10:19,350 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {7302#true} {7302#true} #60#return; {7302#true} is VALID [2018-11-23 12:10:19,350 INFO L256 TraceCheckUtils]: 4: Hoare triple {7302#true} call #t~ret4 := main(); {7302#true} is VALID [2018-11-23 12:10:19,350 INFO L273 TraceCheckUtils]: 5: Hoare triple {7302#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {7304#(= main_~i~0 0)} is VALID [2018-11-23 12:10:19,351 INFO L273 TraceCheckUtils]: 6: Hoare triple {7304#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7305#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:19,352 INFO L273 TraceCheckUtils]: 7: Hoare triple {7305#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7306#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:19,352 INFO L273 TraceCheckUtils]: 8: Hoare triple {7306#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7307#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:19,353 INFO L273 TraceCheckUtils]: 9: Hoare triple {7307#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7308#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:19,354 INFO L273 TraceCheckUtils]: 10: Hoare triple {7308#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7309#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:19,354 INFO L273 TraceCheckUtils]: 11: Hoare triple {7309#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7310#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:19,355 INFO L273 TraceCheckUtils]: 12: Hoare triple {7310#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7311#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:19,356 INFO L273 TraceCheckUtils]: 13: Hoare triple {7311#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7312#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:19,357 INFO L273 TraceCheckUtils]: 14: Hoare triple {7312#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7313#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:19,358 INFO L273 TraceCheckUtils]: 15: Hoare triple {7313#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7314#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:19,359 INFO L273 TraceCheckUtils]: 16: Hoare triple {7314#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7315#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:19,360 INFO L273 TraceCheckUtils]: 17: Hoare triple {7315#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7316#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:19,361 INFO L273 TraceCheckUtils]: 18: Hoare triple {7316#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7317#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:19,362 INFO L273 TraceCheckUtils]: 19: Hoare triple {7317#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7318#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:19,363 INFO L273 TraceCheckUtils]: 20: Hoare triple {7318#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7319#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:19,364 INFO L273 TraceCheckUtils]: 21: Hoare triple {7319#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7320#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:19,365 INFO L273 TraceCheckUtils]: 22: Hoare triple {7320#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7321#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:19,366 INFO L273 TraceCheckUtils]: 23: Hoare triple {7321#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7322#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:19,367 INFO L273 TraceCheckUtils]: 24: Hoare triple {7322#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7323#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:19,368 INFO L273 TraceCheckUtils]: 25: Hoare triple {7323#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7324#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:19,369 INFO L273 TraceCheckUtils]: 26: Hoare triple {7324#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7325#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:19,370 INFO L273 TraceCheckUtils]: 27: Hoare triple {7325#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7326#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:19,371 INFO L273 TraceCheckUtils]: 28: Hoare triple {7326#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7327#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:19,372 INFO L273 TraceCheckUtils]: 29: Hoare triple {7327#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7328#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:19,372 INFO L273 TraceCheckUtils]: 30: Hoare triple {7328#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7329#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:19,373 INFO L273 TraceCheckUtils]: 31: Hoare triple {7329#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7330#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:19,374 INFO L273 TraceCheckUtils]: 32: Hoare triple {7330#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7331#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:19,375 INFO L273 TraceCheckUtils]: 33: Hoare triple {7331#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7332#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:19,376 INFO L273 TraceCheckUtils]: 34: Hoare triple {7332#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7333#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:19,377 INFO L273 TraceCheckUtils]: 35: Hoare triple {7333#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7334#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:19,378 INFO L273 TraceCheckUtils]: 36: Hoare triple {7334#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7335#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:19,379 INFO L273 TraceCheckUtils]: 37: Hoare triple {7335#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7336#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:19,380 INFO L273 TraceCheckUtils]: 38: Hoare triple {7336#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7337#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:19,381 INFO L273 TraceCheckUtils]: 39: Hoare triple {7337#(<= main_~i~0 33)} assume !(~i~0 < 100000); {7303#false} is VALID [2018-11-23 12:10:19,381 INFO L273 TraceCheckUtils]: 40: Hoare triple {7303#false} ~i~0 := 1; {7303#false} is VALID [2018-11-23 12:10:19,381 INFO L273 TraceCheckUtils]: 41: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7303#false} is VALID [2018-11-23 12:10:19,381 INFO L273 TraceCheckUtils]: 42: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7303#false} is VALID [2018-11-23 12:10:19,381 INFO L273 TraceCheckUtils]: 43: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7303#false} is VALID [2018-11-23 12:10:19,382 INFO L273 TraceCheckUtils]: 44: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7303#false} is VALID [2018-11-23 12:10:19,382 INFO L273 TraceCheckUtils]: 45: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7303#false} is VALID [2018-11-23 12:10:19,382 INFO L273 TraceCheckUtils]: 46: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7303#false} is VALID [2018-11-23 12:10:19,382 INFO L273 TraceCheckUtils]: 47: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7303#false} is VALID [2018-11-23 12:10:19,382 INFO L273 TraceCheckUtils]: 48: Hoare triple {7303#false} assume !(~i~0 < 100000); {7303#false} is VALID [2018-11-23 12:10:19,383 INFO L273 TraceCheckUtils]: 49: Hoare triple {7303#false} ~i~0 := 1;~j~0 := 0; {7303#false} is VALID [2018-11-23 12:10:19,383 INFO L273 TraceCheckUtils]: 50: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {7303#false} is VALID [2018-11-23 12:10:19,383 INFO L256 TraceCheckUtils]: 51: Hoare triple {7303#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {7303#false} is VALID [2018-11-23 12:10:19,383 INFO L273 TraceCheckUtils]: 52: Hoare triple {7303#false} ~cond := #in~cond; {7303#false} is VALID [2018-11-23 12:10:19,383 INFO L273 TraceCheckUtils]: 53: Hoare triple {7303#false} assume 0 == ~cond; {7303#false} is VALID [2018-11-23 12:10:19,383 INFO L273 TraceCheckUtils]: 54: Hoare triple {7303#false} assume !false; {7303#false} is VALID [2018-11-23 12:10:19,386 INFO L134 CoverageAnalysis]: Checked inductivity of 589 backedges. 0 proven. 561 refuted. 0 times theorem prover too weak. 28 trivial. 0 not checked. [2018-11-23 12:10:19,387 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:19,387 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 20 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 20 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:19,396 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:10:19,442 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:19,471 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:19,472 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:19,675 INFO L256 TraceCheckUtils]: 0: Hoare triple {7302#true} call ULTIMATE.init(); {7302#true} is VALID [2018-11-23 12:10:19,675 INFO L273 TraceCheckUtils]: 1: Hoare triple {7302#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {7302#true} is VALID [2018-11-23 12:10:19,676 INFO L273 TraceCheckUtils]: 2: Hoare triple {7302#true} assume true; {7302#true} is VALID [2018-11-23 12:10:19,676 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {7302#true} {7302#true} #60#return; {7302#true} is VALID [2018-11-23 12:10:19,676 INFO L256 TraceCheckUtils]: 4: Hoare triple {7302#true} call #t~ret4 := main(); {7302#true} is VALID [2018-11-23 12:10:19,677 INFO L273 TraceCheckUtils]: 5: Hoare triple {7302#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {7356#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:19,678 INFO L273 TraceCheckUtils]: 6: Hoare triple {7356#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7305#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:19,678 INFO L273 TraceCheckUtils]: 7: Hoare triple {7305#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7306#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:19,679 INFO L273 TraceCheckUtils]: 8: Hoare triple {7306#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7307#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:19,680 INFO L273 TraceCheckUtils]: 9: Hoare triple {7307#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7308#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:19,681 INFO L273 TraceCheckUtils]: 10: Hoare triple {7308#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7309#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:19,682 INFO L273 TraceCheckUtils]: 11: Hoare triple {7309#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7310#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:19,683 INFO L273 TraceCheckUtils]: 12: Hoare triple {7310#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7311#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:19,684 INFO L273 TraceCheckUtils]: 13: Hoare triple {7311#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7312#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:19,685 INFO L273 TraceCheckUtils]: 14: Hoare triple {7312#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7313#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:19,686 INFO L273 TraceCheckUtils]: 15: Hoare triple {7313#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7314#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:19,687 INFO L273 TraceCheckUtils]: 16: Hoare triple {7314#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7315#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:19,688 INFO L273 TraceCheckUtils]: 17: Hoare triple {7315#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7316#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:19,689 INFO L273 TraceCheckUtils]: 18: Hoare triple {7316#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7317#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:19,690 INFO L273 TraceCheckUtils]: 19: Hoare triple {7317#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7318#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:19,691 INFO L273 TraceCheckUtils]: 20: Hoare triple {7318#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7319#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:19,692 INFO L273 TraceCheckUtils]: 21: Hoare triple {7319#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7320#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:19,693 INFO L273 TraceCheckUtils]: 22: Hoare triple {7320#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7321#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:19,694 INFO L273 TraceCheckUtils]: 23: Hoare triple {7321#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7322#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:19,695 INFO L273 TraceCheckUtils]: 24: Hoare triple {7322#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7323#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:19,696 INFO L273 TraceCheckUtils]: 25: Hoare triple {7323#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7324#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:19,697 INFO L273 TraceCheckUtils]: 26: Hoare triple {7324#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7325#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:19,698 INFO L273 TraceCheckUtils]: 27: Hoare triple {7325#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7326#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:19,699 INFO L273 TraceCheckUtils]: 28: Hoare triple {7326#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7327#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:19,700 INFO L273 TraceCheckUtils]: 29: Hoare triple {7327#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7328#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:19,701 INFO L273 TraceCheckUtils]: 30: Hoare triple {7328#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7329#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:19,702 INFO L273 TraceCheckUtils]: 31: Hoare triple {7329#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7330#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:19,702 INFO L273 TraceCheckUtils]: 32: Hoare triple {7330#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7331#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:19,703 INFO L273 TraceCheckUtils]: 33: Hoare triple {7331#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7332#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:19,704 INFO L273 TraceCheckUtils]: 34: Hoare triple {7332#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7333#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:19,705 INFO L273 TraceCheckUtils]: 35: Hoare triple {7333#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7334#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:19,706 INFO L273 TraceCheckUtils]: 36: Hoare triple {7334#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7335#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:19,707 INFO L273 TraceCheckUtils]: 37: Hoare triple {7335#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7336#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:19,708 INFO L273 TraceCheckUtils]: 38: Hoare triple {7336#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7337#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:19,709 INFO L273 TraceCheckUtils]: 39: Hoare triple {7337#(<= main_~i~0 33)} assume !(~i~0 < 100000); {7303#false} is VALID [2018-11-23 12:10:19,709 INFO L273 TraceCheckUtils]: 40: Hoare triple {7303#false} ~i~0 := 1; {7303#false} is VALID [2018-11-23 12:10:19,709 INFO L273 TraceCheckUtils]: 41: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7303#false} is VALID [2018-11-23 12:10:19,709 INFO L273 TraceCheckUtils]: 42: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7303#false} is VALID [2018-11-23 12:10:19,710 INFO L273 TraceCheckUtils]: 43: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7303#false} is VALID [2018-11-23 12:10:19,710 INFO L273 TraceCheckUtils]: 44: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7303#false} is VALID [2018-11-23 12:10:19,710 INFO L273 TraceCheckUtils]: 45: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7303#false} is VALID [2018-11-23 12:10:19,710 INFO L273 TraceCheckUtils]: 46: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7303#false} is VALID [2018-11-23 12:10:19,710 INFO L273 TraceCheckUtils]: 47: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7303#false} is VALID [2018-11-23 12:10:19,710 INFO L273 TraceCheckUtils]: 48: Hoare triple {7303#false} assume !(~i~0 < 100000); {7303#false} is VALID [2018-11-23 12:10:19,711 INFO L273 TraceCheckUtils]: 49: Hoare triple {7303#false} ~i~0 := 1;~j~0 := 0; {7303#false} is VALID [2018-11-23 12:10:19,711 INFO L273 TraceCheckUtils]: 50: Hoare triple {7303#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {7303#false} is VALID [2018-11-23 12:10:19,711 INFO L256 TraceCheckUtils]: 51: Hoare triple {7303#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {7303#false} is VALID [2018-11-23 12:10:19,711 INFO L273 TraceCheckUtils]: 52: Hoare triple {7303#false} ~cond := #in~cond; {7303#false} is VALID [2018-11-23 12:10:19,712 INFO L273 TraceCheckUtils]: 53: Hoare triple {7303#false} assume 0 == ~cond; {7303#false} is VALID [2018-11-23 12:10:19,712 INFO L273 TraceCheckUtils]: 54: Hoare triple {7303#false} assume !false; {7303#false} is VALID [2018-11-23 12:10:19,714 INFO L134 CoverageAnalysis]: Checked inductivity of 589 backedges. 0 proven. 561 refuted. 0 times theorem prover too weak. 28 trivial. 0 not checked. [2018-11-23 12:10:19,740 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:19,740 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [36, 36] total 37 [2018-11-23 12:10:19,741 INFO L78 Accepts]: Start accepts. Automaton has 37 states. Word has length 55 [2018-11-23 12:10:19,741 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:19,741 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 37 states. [2018-11-23 12:10:19,780 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 51 edges. 51 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:19,781 INFO L459 AbstractCegarLoop]: Interpolant automaton has 37 states [2018-11-23 12:10:19,781 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 37 interpolants. [2018-11-23 12:10:19,782 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=666, Invalid=666, Unknown=0, NotChecked=0, Total=1332 [2018-11-23 12:10:19,782 INFO L87 Difference]: Start difference. First operand 59 states and 61 transitions. Second operand 37 states. [2018-11-23 12:10:21,512 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:21,512 INFO L93 Difference]: Finished difference Result 91 states and 99 transitions. [2018-11-23 12:10:21,512 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 36 states. [2018-11-23 12:10:21,512 INFO L78 Accepts]: Start accepts. Automaton has 37 states. Word has length 55 [2018-11-23 12:10:21,513 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:21,513 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 37 states. [2018-11-23 12:10:21,514 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 36 states to 36 states and 89 transitions. [2018-11-23 12:10:21,514 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 37 states. [2018-11-23 12:10:21,515 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 36 states to 36 states and 89 transitions. [2018-11-23 12:10:21,515 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 36 states and 89 transitions. [2018-11-23 12:10:21,649 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 89 edges. 89 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:21,651 INFO L225 Difference]: With dead ends: 91 [2018-11-23 12:10:21,651 INFO L226 Difference]: Without dead ends: 72 [2018-11-23 12:10:21,652 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 90 GetRequests, 55 SyntacticMatches, 0 SemanticMatches, 35 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 64 ImplicationChecksByTransitivity, 0.7s TimeCoverageRelationStatistics Valid=666, Invalid=666, Unknown=0, NotChecked=0, Total=1332 [2018-11-23 12:10:21,653 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 72 states. [2018-11-23 12:10:21,741 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 72 to 60. [2018-11-23 12:10:21,741 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:21,741 INFO L82 GeneralOperation]: Start isEquivalent. First operand 72 states. Second operand 60 states. [2018-11-23 12:10:21,741 INFO L74 IsIncluded]: Start isIncluded. First operand 72 states. Second operand 60 states. [2018-11-23 12:10:21,741 INFO L87 Difference]: Start difference. First operand 72 states. Second operand 60 states. [2018-11-23 12:10:21,743 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:21,743 INFO L93 Difference]: Finished difference Result 72 states and 78 transitions. [2018-11-23 12:10:21,743 INFO L276 IsEmpty]: Start isEmpty. Operand 72 states and 78 transitions. [2018-11-23 12:10:21,743 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:21,744 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:21,744 INFO L74 IsIncluded]: Start isIncluded. First operand 60 states. Second operand 72 states. [2018-11-23 12:10:21,744 INFO L87 Difference]: Start difference. First operand 60 states. Second operand 72 states. [2018-11-23 12:10:21,745 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:21,745 INFO L93 Difference]: Finished difference Result 72 states and 78 transitions. [2018-11-23 12:10:21,746 INFO L276 IsEmpty]: Start isEmpty. Operand 72 states and 78 transitions. [2018-11-23 12:10:21,746 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:21,746 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:21,746 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:21,746 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:21,747 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 60 states. [2018-11-23 12:10:21,747 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 60 states to 60 states and 62 transitions. [2018-11-23 12:10:21,747 INFO L78 Accepts]: Start accepts. Automaton has 60 states and 62 transitions. Word has length 55 [2018-11-23 12:10:21,748 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:21,748 INFO L480 AbstractCegarLoop]: Abstraction has 60 states and 62 transitions. [2018-11-23 12:10:21,748 INFO L481 AbstractCegarLoop]: Interpolant automaton has 37 states. [2018-11-23 12:10:21,748 INFO L276 IsEmpty]: Start isEmpty. Operand 60 states and 62 transitions. [2018-11-23 12:10:21,748 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 57 [2018-11-23 12:10:21,748 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:21,749 INFO L402 BasicCegarLoop]: trace histogram [34, 7, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:21,749 INFO L423 AbstractCegarLoop]: === Iteration 23 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:21,749 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:21,749 INFO L82 PathProgramCache]: Analyzing trace with hash -2123218487, now seen corresponding path program 20 times [2018-11-23 12:10:21,749 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:21,749 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:21,750 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:21,750 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:10:21,750 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:21,778 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:22,932 INFO L256 TraceCheckUtils]: 0: Hoare triple {7917#true} call ULTIMATE.init(); {7917#true} is VALID [2018-11-23 12:10:22,932 INFO L273 TraceCheckUtils]: 1: Hoare triple {7917#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {7917#true} is VALID [2018-11-23 12:10:22,933 INFO L273 TraceCheckUtils]: 2: Hoare triple {7917#true} assume true; {7917#true} is VALID [2018-11-23 12:10:22,933 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {7917#true} {7917#true} #60#return; {7917#true} is VALID [2018-11-23 12:10:22,933 INFO L256 TraceCheckUtils]: 4: Hoare triple {7917#true} call #t~ret4 := main(); {7917#true} is VALID [2018-11-23 12:10:22,934 INFO L273 TraceCheckUtils]: 5: Hoare triple {7917#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {7919#(= main_~i~0 0)} is VALID [2018-11-23 12:10:22,935 INFO L273 TraceCheckUtils]: 6: Hoare triple {7919#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7920#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:22,935 INFO L273 TraceCheckUtils]: 7: Hoare triple {7920#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7921#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:22,936 INFO L273 TraceCheckUtils]: 8: Hoare triple {7921#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7922#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:22,937 INFO L273 TraceCheckUtils]: 9: Hoare triple {7922#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7923#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:22,957 INFO L273 TraceCheckUtils]: 10: Hoare triple {7923#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7924#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:22,958 INFO L273 TraceCheckUtils]: 11: Hoare triple {7924#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7925#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:22,958 INFO L273 TraceCheckUtils]: 12: Hoare triple {7925#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7926#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:22,959 INFO L273 TraceCheckUtils]: 13: Hoare triple {7926#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7927#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:22,960 INFO L273 TraceCheckUtils]: 14: Hoare triple {7927#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7928#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:22,961 INFO L273 TraceCheckUtils]: 15: Hoare triple {7928#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7929#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:22,962 INFO L273 TraceCheckUtils]: 16: Hoare triple {7929#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7930#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:22,963 INFO L273 TraceCheckUtils]: 17: Hoare triple {7930#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7931#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:22,964 INFO L273 TraceCheckUtils]: 18: Hoare triple {7931#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7932#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:22,965 INFO L273 TraceCheckUtils]: 19: Hoare triple {7932#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7933#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:22,966 INFO L273 TraceCheckUtils]: 20: Hoare triple {7933#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7934#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:22,967 INFO L273 TraceCheckUtils]: 21: Hoare triple {7934#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7935#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:22,968 INFO L273 TraceCheckUtils]: 22: Hoare triple {7935#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7936#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:22,969 INFO L273 TraceCheckUtils]: 23: Hoare triple {7936#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7937#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:22,970 INFO L273 TraceCheckUtils]: 24: Hoare triple {7937#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7938#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:22,971 INFO L273 TraceCheckUtils]: 25: Hoare triple {7938#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7939#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:22,972 INFO L273 TraceCheckUtils]: 26: Hoare triple {7939#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7940#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:22,973 INFO L273 TraceCheckUtils]: 27: Hoare triple {7940#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7941#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:22,974 INFO L273 TraceCheckUtils]: 28: Hoare triple {7941#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7942#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:22,975 INFO L273 TraceCheckUtils]: 29: Hoare triple {7942#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7943#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:22,976 INFO L273 TraceCheckUtils]: 30: Hoare triple {7943#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7944#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:22,977 INFO L273 TraceCheckUtils]: 31: Hoare triple {7944#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7945#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:22,978 INFO L273 TraceCheckUtils]: 32: Hoare triple {7945#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7946#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:22,979 INFO L273 TraceCheckUtils]: 33: Hoare triple {7946#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7947#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:22,981 INFO L273 TraceCheckUtils]: 34: Hoare triple {7947#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7948#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:22,982 INFO L273 TraceCheckUtils]: 35: Hoare triple {7948#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7949#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:22,983 INFO L273 TraceCheckUtils]: 36: Hoare triple {7949#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7950#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:22,984 INFO L273 TraceCheckUtils]: 37: Hoare triple {7950#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7951#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:22,985 INFO L273 TraceCheckUtils]: 38: Hoare triple {7951#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7952#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:22,986 INFO L273 TraceCheckUtils]: 39: Hoare triple {7952#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7953#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:22,987 INFO L273 TraceCheckUtils]: 40: Hoare triple {7953#(<= main_~i~0 34)} assume !(~i~0 < 100000); {7918#false} is VALID [2018-11-23 12:10:22,987 INFO L273 TraceCheckUtils]: 41: Hoare triple {7918#false} ~i~0 := 1; {7918#false} is VALID [2018-11-23 12:10:22,987 INFO L273 TraceCheckUtils]: 42: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7918#false} is VALID [2018-11-23 12:10:22,987 INFO L273 TraceCheckUtils]: 43: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7918#false} is VALID [2018-11-23 12:10:22,987 INFO L273 TraceCheckUtils]: 44: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7918#false} is VALID [2018-11-23 12:10:22,988 INFO L273 TraceCheckUtils]: 45: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7918#false} is VALID [2018-11-23 12:10:22,988 INFO L273 TraceCheckUtils]: 46: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7918#false} is VALID [2018-11-23 12:10:22,988 INFO L273 TraceCheckUtils]: 47: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7918#false} is VALID [2018-11-23 12:10:22,988 INFO L273 TraceCheckUtils]: 48: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7918#false} is VALID [2018-11-23 12:10:22,989 INFO L273 TraceCheckUtils]: 49: Hoare triple {7918#false} assume !(~i~0 < 100000); {7918#false} is VALID [2018-11-23 12:10:22,989 INFO L273 TraceCheckUtils]: 50: Hoare triple {7918#false} ~i~0 := 1;~j~0 := 0; {7918#false} is VALID [2018-11-23 12:10:22,989 INFO L273 TraceCheckUtils]: 51: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {7918#false} is VALID [2018-11-23 12:10:22,989 INFO L256 TraceCheckUtils]: 52: Hoare triple {7918#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {7918#false} is VALID [2018-11-23 12:10:22,990 INFO L273 TraceCheckUtils]: 53: Hoare triple {7918#false} ~cond := #in~cond; {7918#false} is VALID [2018-11-23 12:10:22,990 INFO L273 TraceCheckUtils]: 54: Hoare triple {7918#false} assume 0 == ~cond; {7918#false} is VALID [2018-11-23 12:10:22,990 INFO L273 TraceCheckUtils]: 55: Hoare triple {7918#false} assume !false; {7918#false} is VALID [2018-11-23 12:10:22,994 INFO L134 CoverageAnalysis]: Checked inductivity of 623 backedges. 0 proven. 595 refuted. 0 times theorem prover too weak. 28 trivial. 0 not checked. [2018-11-23 12:10:22,994 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:22,994 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 21 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 21 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:23,028 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:10:23,077 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:10:23,077 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:23,094 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:23,095 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:23,323 INFO L256 TraceCheckUtils]: 0: Hoare triple {7917#true} call ULTIMATE.init(); {7917#true} is VALID [2018-11-23 12:10:23,324 INFO L273 TraceCheckUtils]: 1: Hoare triple {7917#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {7917#true} is VALID [2018-11-23 12:10:23,324 INFO L273 TraceCheckUtils]: 2: Hoare triple {7917#true} assume true; {7917#true} is VALID [2018-11-23 12:10:23,324 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {7917#true} {7917#true} #60#return; {7917#true} is VALID [2018-11-23 12:10:23,324 INFO L256 TraceCheckUtils]: 4: Hoare triple {7917#true} call #t~ret4 := main(); {7917#true} is VALID [2018-11-23 12:10:23,325 INFO L273 TraceCheckUtils]: 5: Hoare triple {7917#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {7972#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:23,326 INFO L273 TraceCheckUtils]: 6: Hoare triple {7972#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7920#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:23,326 INFO L273 TraceCheckUtils]: 7: Hoare triple {7920#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7921#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:23,327 INFO L273 TraceCheckUtils]: 8: Hoare triple {7921#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7922#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:23,328 INFO L273 TraceCheckUtils]: 9: Hoare triple {7922#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7923#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:23,328 INFO L273 TraceCheckUtils]: 10: Hoare triple {7923#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7924#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:23,329 INFO L273 TraceCheckUtils]: 11: Hoare triple {7924#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7925#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:23,330 INFO L273 TraceCheckUtils]: 12: Hoare triple {7925#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7926#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:23,331 INFO L273 TraceCheckUtils]: 13: Hoare triple {7926#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7927#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:23,332 INFO L273 TraceCheckUtils]: 14: Hoare triple {7927#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7928#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:23,333 INFO L273 TraceCheckUtils]: 15: Hoare triple {7928#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7929#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:23,334 INFO L273 TraceCheckUtils]: 16: Hoare triple {7929#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7930#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:23,335 INFO L273 TraceCheckUtils]: 17: Hoare triple {7930#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7931#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:23,336 INFO L273 TraceCheckUtils]: 18: Hoare triple {7931#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7932#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:23,337 INFO L273 TraceCheckUtils]: 19: Hoare triple {7932#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7933#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:23,338 INFO L273 TraceCheckUtils]: 20: Hoare triple {7933#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7934#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:23,339 INFO L273 TraceCheckUtils]: 21: Hoare triple {7934#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7935#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:23,340 INFO L273 TraceCheckUtils]: 22: Hoare triple {7935#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7936#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:23,341 INFO L273 TraceCheckUtils]: 23: Hoare triple {7936#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7937#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:23,342 INFO L273 TraceCheckUtils]: 24: Hoare triple {7937#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7938#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:23,343 INFO L273 TraceCheckUtils]: 25: Hoare triple {7938#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7939#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:23,344 INFO L273 TraceCheckUtils]: 26: Hoare triple {7939#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7940#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:23,345 INFO L273 TraceCheckUtils]: 27: Hoare triple {7940#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7941#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:23,346 INFO L273 TraceCheckUtils]: 28: Hoare triple {7941#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7942#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:23,347 INFO L273 TraceCheckUtils]: 29: Hoare triple {7942#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7943#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:23,348 INFO L273 TraceCheckUtils]: 30: Hoare triple {7943#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7944#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:23,349 INFO L273 TraceCheckUtils]: 31: Hoare triple {7944#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7945#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:23,350 INFO L273 TraceCheckUtils]: 32: Hoare triple {7945#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7946#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:23,351 INFO L273 TraceCheckUtils]: 33: Hoare triple {7946#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7947#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:23,352 INFO L273 TraceCheckUtils]: 34: Hoare triple {7947#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7948#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:23,353 INFO L273 TraceCheckUtils]: 35: Hoare triple {7948#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7949#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:23,354 INFO L273 TraceCheckUtils]: 36: Hoare triple {7949#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7950#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:23,355 INFO L273 TraceCheckUtils]: 37: Hoare triple {7950#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7951#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:23,356 INFO L273 TraceCheckUtils]: 38: Hoare triple {7951#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7952#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:23,356 INFO L273 TraceCheckUtils]: 39: Hoare triple {7952#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {7953#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:23,357 INFO L273 TraceCheckUtils]: 40: Hoare triple {7953#(<= main_~i~0 34)} assume !(~i~0 < 100000); {7918#false} is VALID [2018-11-23 12:10:23,357 INFO L273 TraceCheckUtils]: 41: Hoare triple {7918#false} ~i~0 := 1; {7918#false} is VALID [2018-11-23 12:10:23,358 INFO L273 TraceCheckUtils]: 42: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7918#false} is VALID [2018-11-23 12:10:23,358 INFO L273 TraceCheckUtils]: 43: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7918#false} is VALID [2018-11-23 12:10:23,358 INFO L273 TraceCheckUtils]: 44: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7918#false} is VALID [2018-11-23 12:10:23,358 INFO L273 TraceCheckUtils]: 45: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7918#false} is VALID [2018-11-23 12:10:23,358 INFO L273 TraceCheckUtils]: 46: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7918#false} is VALID [2018-11-23 12:10:23,358 INFO L273 TraceCheckUtils]: 47: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7918#false} is VALID [2018-11-23 12:10:23,359 INFO L273 TraceCheckUtils]: 48: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {7918#false} is VALID [2018-11-23 12:10:23,359 INFO L273 TraceCheckUtils]: 49: Hoare triple {7918#false} assume !(~i~0 < 100000); {7918#false} is VALID [2018-11-23 12:10:23,359 INFO L273 TraceCheckUtils]: 50: Hoare triple {7918#false} ~i~0 := 1;~j~0 := 0; {7918#false} is VALID [2018-11-23 12:10:23,359 INFO L273 TraceCheckUtils]: 51: Hoare triple {7918#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {7918#false} is VALID [2018-11-23 12:10:23,359 INFO L256 TraceCheckUtils]: 52: Hoare triple {7918#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {7918#false} is VALID [2018-11-23 12:10:23,360 INFO L273 TraceCheckUtils]: 53: Hoare triple {7918#false} ~cond := #in~cond; {7918#false} is VALID [2018-11-23 12:10:23,360 INFO L273 TraceCheckUtils]: 54: Hoare triple {7918#false} assume 0 == ~cond; {7918#false} is VALID [2018-11-23 12:10:23,360 INFO L273 TraceCheckUtils]: 55: Hoare triple {7918#false} assume !false; {7918#false} is VALID [2018-11-23 12:10:23,362 INFO L134 CoverageAnalysis]: Checked inductivity of 623 backedges. 0 proven. 595 refuted. 0 times theorem prover too weak. 28 trivial. 0 not checked. [2018-11-23 12:10:23,381 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:23,381 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [37, 37] total 38 [2018-11-23 12:10:23,382 INFO L78 Accepts]: Start accepts. Automaton has 38 states. Word has length 56 [2018-11-23 12:10:23,382 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:23,382 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 38 states. [2018-11-23 12:10:23,441 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 52 edges. 52 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:23,441 INFO L459 AbstractCegarLoop]: Interpolant automaton has 38 states [2018-11-23 12:10:23,441 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 38 interpolants. [2018-11-23 12:10:23,442 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=703, Invalid=703, Unknown=0, NotChecked=0, Total=1406 [2018-11-23 12:10:23,442 INFO L87 Difference]: Start difference. First operand 60 states and 62 transitions. Second operand 38 states. [2018-11-23 12:10:24,244 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:24,244 INFO L93 Difference]: Finished difference Result 92 states and 100 transitions. [2018-11-23 12:10:24,245 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 37 states. [2018-11-23 12:10:24,245 INFO L78 Accepts]: Start accepts. Automaton has 38 states. Word has length 56 [2018-11-23 12:10:24,245 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:24,245 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 38 states. [2018-11-23 12:10:24,246 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 37 states to 37 states and 90 transitions. [2018-11-23 12:10:24,249 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 38 states. [2018-11-23 12:10:24,250 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 37 states to 37 states and 90 transitions. [2018-11-23 12:10:24,251 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 37 states and 90 transitions. [2018-11-23 12:10:24,343 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 90 edges. 90 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:24,344 INFO L225 Difference]: With dead ends: 92 [2018-11-23 12:10:24,344 INFO L226 Difference]: Without dead ends: 73 [2018-11-23 12:10:24,345 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 92 GetRequests, 56 SyntacticMatches, 0 SemanticMatches, 36 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 66 ImplicationChecksByTransitivity, 0.9s TimeCoverageRelationStatistics Valid=703, Invalid=703, Unknown=0, NotChecked=0, Total=1406 [2018-11-23 12:10:24,345 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 73 states. [2018-11-23 12:10:24,387 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 73 to 61. [2018-11-23 12:10:24,388 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:24,388 INFO L82 GeneralOperation]: Start isEquivalent. First operand 73 states. Second operand 61 states. [2018-11-23 12:10:24,388 INFO L74 IsIncluded]: Start isIncluded. First operand 73 states. Second operand 61 states. [2018-11-23 12:10:24,388 INFO L87 Difference]: Start difference. First operand 73 states. Second operand 61 states. [2018-11-23 12:10:24,390 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:24,390 INFO L93 Difference]: Finished difference Result 73 states and 79 transitions. [2018-11-23 12:10:24,390 INFO L276 IsEmpty]: Start isEmpty. Operand 73 states and 79 transitions. [2018-11-23 12:10:24,390 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:24,391 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:24,391 INFO L74 IsIncluded]: Start isIncluded. First operand 61 states. Second operand 73 states. [2018-11-23 12:10:24,391 INFO L87 Difference]: Start difference. First operand 61 states. Second operand 73 states. [2018-11-23 12:10:24,392 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:24,393 INFO L93 Difference]: Finished difference Result 73 states and 79 transitions. [2018-11-23 12:10:24,393 INFO L276 IsEmpty]: Start isEmpty. Operand 73 states and 79 transitions. [2018-11-23 12:10:24,393 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:24,393 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:24,393 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:24,393 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:24,394 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 61 states. [2018-11-23 12:10:24,394 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 61 states to 61 states and 63 transitions. [2018-11-23 12:10:24,395 INFO L78 Accepts]: Start accepts. Automaton has 61 states and 63 transitions. Word has length 56 [2018-11-23 12:10:24,395 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:24,395 INFO L480 AbstractCegarLoop]: Abstraction has 61 states and 63 transitions. [2018-11-23 12:10:24,395 INFO L481 AbstractCegarLoop]: Interpolant automaton has 38 states. [2018-11-23 12:10:24,395 INFO L276 IsEmpty]: Start isEmpty. Operand 61 states and 63 transitions. [2018-11-23 12:10:24,396 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 58 [2018-11-23 12:10:24,396 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:24,396 INFO L402 BasicCegarLoop]: trace histogram [35, 7, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:24,396 INFO L423 AbstractCegarLoop]: === Iteration 24 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:24,396 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:24,396 INFO L82 PathProgramCache]: Analyzing trace with hash 1573635621, now seen corresponding path program 21 times [2018-11-23 12:10:24,397 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:24,397 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:24,397 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:24,397 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:24,398 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:24,427 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:25,115 INFO L256 TraceCheckUtils]: 0: Hoare triple {8542#true} call ULTIMATE.init(); {8542#true} is VALID [2018-11-23 12:10:25,116 INFO L273 TraceCheckUtils]: 1: Hoare triple {8542#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {8542#true} is VALID [2018-11-23 12:10:25,116 INFO L273 TraceCheckUtils]: 2: Hoare triple {8542#true} assume true; {8542#true} is VALID [2018-11-23 12:10:25,116 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {8542#true} {8542#true} #60#return; {8542#true} is VALID [2018-11-23 12:10:25,116 INFO L256 TraceCheckUtils]: 4: Hoare triple {8542#true} call #t~ret4 := main(); {8542#true} is VALID [2018-11-23 12:10:25,117 INFO L273 TraceCheckUtils]: 5: Hoare triple {8542#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {8544#(= main_~i~0 0)} is VALID [2018-11-23 12:10:25,118 INFO L273 TraceCheckUtils]: 6: Hoare triple {8544#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8545#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:25,119 INFO L273 TraceCheckUtils]: 7: Hoare triple {8545#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8546#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:25,119 INFO L273 TraceCheckUtils]: 8: Hoare triple {8546#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8547#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:25,120 INFO L273 TraceCheckUtils]: 9: Hoare triple {8547#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8548#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:25,121 INFO L273 TraceCheckUtils]: 10: Hoare triple {8548#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8549#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:25,122 INFO L273 TraceCheckUtils]: 11: Hoare triple {8549#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8550#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:25,123 INFO L273 TraceCheckUtils]: 12: Hoare triple {8550#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8551#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:25,124 INFO L273 TraceCheckUtils]: 13: Hoare triple {8551#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8552#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:25,125 INFO L273 TraceCheckUtils]: 14: Hoare triple {8552#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8553#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:25,126 INFO L273 TraceCheckUtils]: 15: Hoare triple {8553#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8554#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:25,127 INFO L273 TraceCheckUtils]: 16: Hoare triple {8554#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8555#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:25,128 INFO L273 TraceCheckUtils]: 17: Hoare triple {8555#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8556#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:25,129 INFO L273 TraceCheckUtils]: 18: Hoare triple {8556#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8557#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:25,130 INFO L273 TraceCheckUtils]: 19: Hoare triple {8557#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8558#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:25,131 INFO L273 TraceCheckUtils]: 20: Hoare triple {8558#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8559#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:25,132 INFO L273 TraceCheckUtils]: 21: Hoare triple {8559#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8560#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:25,133 INFO L273 TraceCheckUtils]: 22: Hoare triple {8560#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8561#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:25,134 INFO L273 TraceCheckUtils]: 23: Hoare triple {8561#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8562#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:25,135 INFO L273 TraceCheckUtils]: 24: Hoare triple {8562#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8563#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:25,136 INFO L273 TraceCheckUtils]: 25: Hoare triple {8563#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8564#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:25,137 INFO L273 TraceCheckUtils]: 26: Hoare triple {8564#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8565#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:25,138 INFO L273 TraceCheckUtils]: 27: Hoare triple {8565#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8566#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:25,139 INFO L273 TraceCheckUtils]: 28: Hoare triple {8566#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8567#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:25,139 INFO L273 TraceCheckUtils]: 29: Hoare triple {8567#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8568#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:25,141 INFO L273 TraceCheckUtils]: 30: Hoare triple {8568#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8569#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:25,142 INFO L273 TraceCheckUtils]: 31: Hoare triple {8569#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8570#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:25,143 INFO L273 TraceCheckUtils]: 32: Hoare triple {8570#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8571#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:25,144 INFO L273 TraceCheckUtils]: 33: Hoare triple {8571#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8572#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:25,145 INFO L273 TraceCheckUtils]: 34: Hoare triple {8572#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8573#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:25,146 INFO L273 TraceCheckUtils]: 35: Hoare triple {8573#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8574#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:25,147 INFO L273 TraceCheckUtils]: 36: Hoare triple {8574#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8575#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:25,147 INFO L273 TraceCheckUtils]: 37: Hoare triple {8575#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8576#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:25,148 INFO L273 TraceCheckUtils]: 38: Hoare triple {8576#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8577#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:25,149 INFO L273 TraceCheckUtils]: 39: Hoare triple {8577#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8578#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:25,150 INFO L273 TraceCheckUtils]: 40: Hoare triple {8578#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8579#(<= main_~i~0 35)} is VALID [2018-11-23 12:10:25,151 INFO L273 TraceCheckUtils]: 41: Hoare triple {8579#(<= main_~i~0 35)} assume !(~i~0 < 100000); {8543#false} is VALID [2018-11-23 12:10:25,151 INFO L273 TraceCheckUtils]: 42: Hoare triple {8543#false} ~i~0 := 1; {8543#false} is VALID [2018-11-23 12:10:25,152 INFO L273 TraceCheckUtils]: 43: Hoare triple {8543#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {8543#false} is VALID [2018-11-23 12:10:25,152 INFO L273 TraceCheckUtils]: 44: Hoare triple {8543#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {8543#false} is VALID [2018-11-23 12:10:25,152 INFO L273 TraceCheckUtils]: 45: Hoare triple {8543#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {8543#false} is VALID [2018-11-23 12:10:25,152 INFO L273 TraceCheckUtils]: 46: Hoare triple {8543#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {8543#false} is VALID [2018-11-23 12:10:25,152 INFO L273 TraceCheckUtils]: 47: Hoare triple {8543#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {8543#false} is VALID [2018-11-23 12:10:25,153 INFO L273 TraceCheckUtils]: 48: Hoare triple {8543#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {8543#false} is VALID [2018-11-23 12:10:25,153 INFO L273 TraceCheckUtils]: 49: Hoare triple {8543#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {8543#false} is VALID [2018-11-23 12:10:25,153 INFO L273 TraceCheckUtils]: 50: Hoare triple {8543#false} assume !(~i~0 < 100000); {8543#false} is VALID [2018-11-23 12:10:25,153 INFO L273 TraceCheckUtils]: 51: Hoare triple {8543#false} ~i~0 := 1;~j~0 := 0; {8543#false} is VALID [2018-11-23 12:10:25,153 INFO L273 TraceCheckUtils]: 52: Hoare triple {8543#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {8543#false} is VALID [2018-11-23 12:10:25,154 INFO L256 TraceCheckUtils]: 53: Hoare triple {8543#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {8543#false} is VALID [2018-11-23 12:10:25,154 INFO L273 TraceCheckUtils]: 54: Hoare triple {8543#false} ~cond := #in~cond; {8543#false} is VALID [2018-11-23 12:10:25,154 INFO L273 TraceCheckUtils]: 55: Hoare triple {8543#false} assume 0 == ~cond; {8543#false} is VALID [2018-11-23 12:10:25,154 INFO L273 TraceCheckUtils]: 56: Hoare triple {8543#false} assume !false; {8543#false} is VALID [2018-11-23 12:10:25,157 INFO L134 CoverageAnalysis]: Checked inductivity of 658 backedges. 0 proven. 630 refuted. 0 times theorem prover too weak. 28 trivial. 0 not checked. [2018-11-23 12:10:25,157 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:25,157 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 22 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 22 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:25,167 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:10:25,298 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 5 check-sat command(s) [2018-11-23 12:10:25,299 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:25,320 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:25,321 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:25,515 INFO L256 TraceCheckUtils]: 0: Hoare triple {8542#true} call ULTIMATE.init(); {8542#true} is VALID [2018-11-23 12:10:25,515 INFO L273 TraceCheckUtils]: 1: Hoare triple {8542#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {8542#true} is VALID [2018-11-23 12:10:25,516 INFO L273 TraceCheckUtils]: 2: Hoare triple {8542#true} assume true; {8542#true} is VALID [2018-11-23 12:10:25,516 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {8542#true} {8542#true} #60#return; {8542#true} is VALID [2018-11-23 12:10:25,516 INFO L256 TraceCheckUtils]: 4: Hoare triple {8542#true} call #t~ret4 := main(); {8542#true} is VALID [2018-11-23 12:10:25,516 INFO L273 TraceCheckUtils]: 5: Hoare triple {8542#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {8542#true} is VALID [2018-11-23 12:10:25,516 INFO L273 TraceCheckUtils]: 6: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,517 INFO L273 TraceCheckUtils]: 7: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,517 INFO L273 TraceCheckUtils]: 8: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,517 INFO L273 TraceCheckUtils]: 9: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,517 INFO L273 TraceCheckUtils]: 10: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,517 INFO L273 TraceCheckUtils]: 11: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,517 INFO L273 TraceCheckUtils]: 12: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,517 INFO L273 TraceCheckUtils]: 13: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,517 INFO L273 TraceCheckUtils]: 14: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,517 INFO L273 TraceCheckUtils]: 15: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,518 INFO L273 TraceCheckUtils]: 16: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,518 INFO L273 TraceCheckUtils]: 17: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,518 INFO L273 TraceCheckUtils]: 18: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,518 INFO L273 TraceCheckUtils]: 19: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,518 INFO L273 TraceCheckUtils]: 20: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,518 INFO L273 TraceCheckUtils]: 21: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,518 INFO L273 TraceCheckUtils]: 22: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,518 INFO L273 TraceCheckUtils]: 23: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,518 INFO L273 TraceCheckUtils]: 24: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,519 INFO L273 TraceCheckUtils]: 25: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,519 INFO L273 TraceCheckUtils]: 26: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,519 INFO L273 TraceCheckUtils]: 27: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,519 INFO L273 TraceCheckUtils]: 28: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,519 INFO L273 TraceCheckUtils]: 29: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,519 INFO L273 TraceCheckUtils]: 30: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,519 INFO L273 TraceCheckUtils]: 31: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,519 INFO L273 TraceCheckUtils]: 32: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,519 INFO L273 TraceCheckUtils]: 33: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,520 INFO L273 TraceCheckUtils]: 34: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,520 INFO L273 TraceCheckUtils]: 35: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,520 INFO L273 TraceCheckUtils]: 36: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,520 INFO L273 TraceCheckUtils]: 37: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,520 INFO L273 TraceCheckUtils]: 38: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,520 INFO L273 TraceCheckUtils]: 39: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,520 INFO L273 TraceCheckUtils]: 40: Hoare triple {8542#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8542#true} is VALID [2018-11-23 12:10:25,520 INFO L273 TraceCheckUtils]: 41: Hoare triple {8542#true} assume !(~i~0 < 100000); {8542#true} is VALID [2018-11-23 12:10:25,521 INFO L273 TraceCheckUtils]: 42: Hoare triple {8542#true} ~i~0 := 1; {8545#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:25,521 INFO L273 TraceCheckUtils]: 43: Hoare triple {8545#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {8554#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:25,522 INFO L273 TraceCheckUtils]: 44: Hoare triple {8554#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {8563#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:25,523 INFO L273 TraceCheckUtils]: 45: Hoare triple {8563#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {8572#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:25,523 INFO L273 TraceCheckUtils]: 46: Hoare triple {8572#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {8721#(<= main_~i~0 37)} is VALID [2018-11-23 12:10:25,524 INFO L273 TraceCheckUtils]: 47: Hoare triple {8721#(<= main_~i~0 37)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {8725#(<= main_~i~0 46)} is VALID [2018-11-23 12:10:25,524 INFO L273 TraceCheckUtils]: 48: Hoare triple {8725#(<= main_~i~0 46)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {8729#(<= main_~i~0 55)} is VALID [2018-11-23 12:10:25,525 INFO L273 TraceCheckUtils]: 49: Hoare triple {8729#(<= main_~i~0 55)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {8733#(<= main_~i~0 64)} is VALID [2018-11-23 12:10:25,526 INFO L273 TraceCheckUtils]: 50: Hoare triple {8733#(<= main_~i~0 64)} assume !(~i~0 < 100000); {8543#false} is VALID [2018-11-23 12:10:25,526 INFO L273 TraceCheckUtils]: 51: Hoare triple {8543#false} ~i~0 := 1;~j~0 := 0; {8543#false} is VALID [2018-11-23 12:10:25,526 INFO L273 TraceCheckUtils]: 52: Hoare triple {8543#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {8543#false} is VALID [2018-11-23 12:10:25,527 INFO L256 TraceCheckUtils]: 53: Hoare triple {8543#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {8543#false} is VALID [2018-11-23 12:10:25,527 INFO L273 TraceCheckUtils]: 54: Hoare triple {8543#false} ~cond := #in~cond; {8543#false} is VALID [2018-11-23 12:10:25,527 INFO L273 TraceCheckUtils]: 55: Hoare triple {8543#false} assume 0 == ~cond; {8543#false} is VALID [2018-11-23 12:10:25,527 INFO L273 TraceCheckUtils]: 56: Hoare triple {8543#false} assume !false; {8543#false} is VALID [2018-11-23 12:10:25,530 INFO L134 CoverageAnalysis]: Checked inductivity of 658 backedges. 0 proven. 28 refuted. 0 times theorem prover too weak. 630 trivial. 0 not checked. [2018-11-23 12:10:25,550 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:25,550 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [38, 10] total 42 [2018-11-23 12:10:25,550 INFO L78 Accepts]: Start accepts. Automaton has 42 states. Word has length 57 [2018-11-23 12:10:25,551 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:25,551 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 42 states. [2018-11-23 12:10:25,602 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 63 edges. 63 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:25,603 INFO L459 AbstractCegarLoop]: Interpolant automaton has 42 states [2018-11-23 12:10:25,603 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 42 interpolants. [2018-11-23 12:10:25,604 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=861, Invalid=861, Unknown=0, NotChecked=0, Total=1722 [2018-11-23 12:10:25,604 INFO L87 Difference]: Start difference. First operand 61 states and 63 transitions. Second operand 42 states. [2018-11-23 12:10:26,965 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:26,965 INFO L93 Difference]: Finished difference Result 110 states and 127 transitions. [2018-11-23 12:10:26,966 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 42 states. [2018-11-23 12:10:26,966 INFO L78 Accepts]: Start accepts. Automaton has 42 states. Word has length 57 [2018-11-23 12:10:26,966 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:26,966 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 42 states. [2018-11-23 12:10:26,968 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 42 states to 42 states and 120 transitions. [2018-11-23 12:10:26,969 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 42 states. [2018-11-23 12:10:26,970 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 42 states to 42 states and 120 transitions. [2018-11-23 12:10:26,970 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 42 states and 120 transitions. [2018-11-23 12:10:27,092 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 120 edges. 120 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:27,094 INFO L225 Difference]: With dead ends: 110 [2018-11-23 12:10:27,094 INFO L226 Difference]: Without dead ends: 91 [2018-11-23 12:10:27,095 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 94 GetRequests, 54 SyntacticMatches, 0 SemanticMatches, 40 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.6s TimeCoverageRelationStatistics Valid=861, Invalid=861, Unknown=0, NotChecked=0, Total=1722 [2018-11-23 12:10:27,095 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 91 states. [2018-11-23 12:10:27,141 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 91 to 67. [2018-11-23 12:10:27,141 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:27,141 INFO L82 GeneralOperation]: Start isEquivalent. First operand 91 states. Second operand 67 states. [2018-11-23 12:10:27,141 INFO L74 IsIncluded]: Start isIncluded. First operand 91 states. Second operand 67 states. [2018-11-23 12:10:27,141 INFO L87 Difference]: Start difference. First operand 91 states. Second operand 67 states. [2018-11-23 12:10:27,143 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:27,143 INFO L93 Difference]: Finished difference Result 91 states and 101 transitions. [2018-11-23 12:10:27,143 INFO L276 IsEmpty]: Start isEmpty. Operand 91 states and 101 transitions. [2018-11-23 12:10:27,144 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:27,144 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:27,144 INFO L74 IsIncluded]: Start isIncluded. First operand 67 states. Second operand 91 states. [2018-11-23 12:10:27,144 INFO L87 Difference]: Start difference. First operand 67 states. Second operand 91 states. [2018-11-23 12:10:27,146 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:27,147 INFO L93 Difference]: Finished difference Result 91 states and 101 transitions. [2018-11-23 12:10:27,147 INFO L276 IsEmpty]: Start isEmpty. Operand 91 states and 101 transitions. [2018-11-23 12:10:27,147 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:27,147 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:27,147 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:27,148 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:27,148 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 67 states. [2018-11-23 12:10:27,149 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 67 states to 67 states and 69 transitions. [2018-11-23 12:10:27,149 INFO L78 Accepts]: Start accepts. Automaton has 67 states and 69 transitions. Word has length 57 [2018-11-23 12:10:27,149 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:27,149 INFO L480 AbstractCegarLoop]: Abstraction has 67 states and 69 transitions. [2018-11-23 12:10:27,149 INFO L481 AbstractCegarLoop]: Interpolant automaton has 42 states. [2018-11-23 12:10:27,149 INFO L276 IsEmpty]: Start isEmpty. Operand 67 states and 69 transitions. [2018-11-23 12:10:27,150 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 64 [2018-11-23 12:10:27,150 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:27,150 INFO L402 BasicCegarLoop]: trace histogram [40, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:27,150 INFO L423 AbstractCegarLoop]: === Iteration 25 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:27,151 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:27,151 INFO L82 PathProgramCache]: Analyzing trace with hash -1366341850, now seen corresponding path program 22 times [2018-11-23 12:10:27,151 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:27,151 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:27,152 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:27,152 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:27,152 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:27,189 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:28,130 INFO L256 TraceCheckUtils]: 0: Hoare triple {9254#true} call ULTIMATE.init(); {9254#true} is VALID [2018-11-23 12:10:28,131 INFO L273 TraceCheckUtils]: 1: Hoare triple {9254#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {9254#true} is VALID [2018-11-23 12:10:28,131 INFO L273 TraceCheckUtils]: 2: Hoare triple {9254#true} assume true; {9254#true} is VALID [2018-11-23 12:10:28,131 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {9254#true} {9254#true} #60#return; {9254#true} is VALID [2018-11-23 12:10:28,131 INFO L256 TraceCheckUtils]: 4: Hoare triple {9254#true} call #t~ret4 := main(); {9254#true} is VALID [2018-11-23 12:10:28,132 INFO L273 TraceCheckUtils]: 5: Hoare triple {9254#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {9256#(= main_~i~0 0)} is VALID [2018-11-23 12:10:28,132 INFO L273 TraceCheckUtils]: 6: Hoare triple {9256#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9257#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:28,133 INFO L273 TraceCheckUtils]: 7: Hoare triple {9257#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9258#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:28,133 INFO L273 TraceCheckUtils]: 8: Hoare triple {9258#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9259#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:28,134 INFO L273 TraceCheckUtils]: 9: Hoare triple {9259#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9260#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:28,135 INFO L273 TraceCheckUtils]: 10: Hoare triple {9260#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9261#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:28,136 INFO L273 TraceCheckUtils]: 11: Hoare triple {9261#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9262#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:28,137 INFO L273 TraceCheckUtils]: 12: Hoare triple {9262#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9263#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:28,137 INFO L273 TraceCheckUtils]: 13: Hoare triple {9263#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9264#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:28,138 INFO L273 TraceCheckUtils]: 14: Hoare triple {9264#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9265#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:28,139 INFO L273 TraceCheckUtils]: 15: Hoare triple {9265#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9266#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:28,140 INFO L273 TraceCheckUtils]: 16: Hoare triple {9266#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9267#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:28,141 INFO L273 TraceCheckUtils]: 17: Hoare triple {9267#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9268#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:28,142 INFO L273 TraceCheckUtils]: 18: Hoare triple {9268#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9269#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:28,143 INFO L273 TraceCheckUtils]: 19: Hoare triple {9269#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9270#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:28,144 INFO L273 TraceCheckUtils]: 20: Hoare triple {9270#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9271#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:28,145 INFO L273 TraceCheckUtils]: 21: Hoare triple {9271#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9272#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:28,146 INFO L273 TraceCheckUtils]: 22: Hoare triple {9272#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9273#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:28,147 INFO L273 TraceCheckUtils]: 23: Hoare triple {9273#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9274#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:28,148 INFO L273 TraceCheckUtils]: 24: Hoare triple {9274#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9275#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:28,149 INFO L273 TraceCheckUtils]: 25: Hoare triple {9275#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9276#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:28,149 INFO L273 TraceCheckUtils]: 26: Hoare triple {9276#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9277#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:28,150 INFO L273 TraceCheckUtils]: 27: Hoare triple {9277#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9278#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:28,151 INFO L273 TraceCheckUtils]: 28: Hoare triple {9278#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9279#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:28,152 INFO L273 TraceCheckUtils]: 29: Hoare triple {9279#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9280#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:28,153 INFO L273 TraceCheckUtils]: 30: Hoare triple {9280#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9281#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:28,154 INFO L273 TraceCheckUtils]: 31: Hoare triple {9281#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9282#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:28,155 INFO L273 TraceCheckUtils]: 32: Hoare triple {9282#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9283#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:28,156 INFO L273 TraceCheckUtils]: 33: Hoare triple {9283#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9284#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:28,157 INFO L273 TraceCheckUtils]: 34: Hoare triple {9284#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9285#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:28,158 INFO L273 TraceCheckUtils]: 35: Hoare triple {9285#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9286#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:28,159 INFO L273 TraceCheckUtils]: 36: Hoare triple {9286#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9287#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:28,160 INFO L273 TraceCheckUtils]: 37: Hoare triple {9287#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9288#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:28,161 INFO L273 TraceCheckUtils]: 38: Hoare triple {9288#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9289#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:28,161 INFO L273 TraceCheckUtils]: 39: Hoare triple {9289#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9290#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:28,162 INFO L273 TraceCheckUtils]: 40: Hoare triple {9290#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9291#(<= main_~i~0 35)} is VALID [2018-11-23 12:10:28,163 INFO L273 TraceCheckUtils]: 41: Hoare triple {9291#(<= main_~i~0 35)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9292#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:28,164 INFO L273 TraceCheckUtils]: 42: Hoare triple {9292#(<= main_~i~0 36)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9293#(<= main_~i~0 37)} is VALID [2018-11-23 12:10:28,165 INFO L273 TraceCheckUtils]: 43: Hoare triple {9293#(<= main_~i~0 37)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9294#(<= main_~i~0 38)} is VALID [2018-11-23 12:10:28,166 INFO L273 TraceCheckUtils]: 44: Hoare triple {9294#(<= main_~i~0 38)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9295#(<= main_~i~0 39)} is VALID [2018-11-23 12:10:28,167 INFO L273 TraceCheckUtils]: 45: Hoare triple {9295#(<= main_~i~0 39)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9296#(<= main_~i~0 40)} is VALID [2018-11-23 12:10:28,168 INFO L273 TraceCheckUtils]: 46: Hoare triple {9296#(<= main_~i~0 40)} assume !(~i~0 < 100000); {9255#false} is VALID [2018-11-23 12:10:28,168 INFO L273 TraceCheckUtils]: 47: Hoare triple {9255#false} ~i~0 := 1; {9255#false} is VALID [2018-11-23 12:10:28,168 INFO L273 TraceCheckUtils]: 48: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,168 INFO L273 TraceCheckUtils]: 49: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,168 INFO L273 TraceCheckUtils]: 50: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,169 INFO L273 TraceCheckUtils]: 51: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,169 INFO L273 TraceCheckUtils]: 52: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,169 INFO L273 TraceCheckUtils]: 53: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,169 INFO L273 TraceCheckUtils]: 54: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,169 INFO L273 TraceCheckUtils]: 55: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,170 INFO L273 TraceCheckUtils]: 56: Hoare triple {9255#false} assume !(~i~0 < 100000); {9255#false} is VALID [2018-11-23 12:10:28,170 INFO L273 TraceCheckUtils]: 57: Hoare triple {9255#false} ~i~0 := 1;~j~0 := 0; {9255#false} is VALID [2018-11-23 12:10:28,170 INFO L273 TraceCheckUtils]: 58: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {9255#false} is VALID [2018-11-23 12:10:28,170 INFO L256 TraceCheckUtils]: 59: Hoare triple {9255#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {9255#false} is VALID [2018-11-23 12:10:28,170 INFO L273 TraceCheckUtils]: 60: Hoare triple {9255#false} ~cond := #in~cond; {9255#false} is VALID [2018-11-23 12:10:28,171 INFO L273 TraceCheckUtils]: 61: Hoare triple {9255#false} assume 0 == ~cond; {9255#false} is VALID [2018-11-23 12:10:28,171 INFO L273 TraceCheckUtils]: 62: Hoare triple {9255#false} assume !false; {9255#false} is VALID [2018-11-23 12:10:28,174 INFO L134 CoverageAnalysis]: Checked inductivity of 856 backedges. 0 proven. 820 refuted. 0 times theorem prover too weak. 36 trivial. 0 not checked. [2018-11-23 12:10:28,174 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:28,174 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 23 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 23 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:28,183 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:10:28,237 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:10:28,238 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:28,259 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:28,261 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:28,667 INFO L256 TraceCheckUtils]: 0: Hoare triple {9254#true} call ULTIMATE.init(); {9254#true} is VALID [2018-11-23 12:10:28,667 INFO L273 TraceCheckUtils]: 1: Hoare triple {9254#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {9254#true} is VALID [2018-11-23 12:10:28,668 INFO L273 TraceCheckUtils]: 2: Hoare triple {9254#true} assume true; {9254#true} is VALID [2018-11-23 12:10:28,668 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {9254#true} {9254#true} #60#return; {9254#true} is VALID [2018-11-23 12:10:28,668 INFO L256 TraceCheckUtils]: 4: Hoare triple {9254#true} call #t~ret4 := main(); {9254#true} is VALID [2018-11-23 12:10:28,668 INFO L273 TraceCheckUtils]: 5: Hoare triple {9254#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {9315#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:28,669 INFO L273 TraceCheckUtils]: 6: Hoare triple {9315#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9257#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:28,671 INFO L273 TraceCheckUtils]: 7: Hoare triple {9257#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9258#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:28,672 INFO L273 TraceCheckUtils]: 8: Hoare triple {9258#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9259#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:28,673 INFO L273 TraceCheckUtils]: 9: Hoare triple {9259#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9260#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:28,674 INFO L273 TraceCheckUtils]: 10: Hoare triple {9260#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9261#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:28,675 INFO L273 TraceCheckUtils]: 11: Hoare triple {9261#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9262#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:28,676 INFO L273 TraceCheckUtils]: 12: Hoare triple {9262#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9263#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:28,677 INFO L273 TraceCheckUtils]: 13: Hoare triple {9263#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9264#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:28,678 INFO L273 TraceCheckUtils]: 14: Hoare triple {9264#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9265#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:28,679 INFO L273 TraceCheckUtils]: 15: Hoare triple {9265#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9266#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:28,680 INFO L273 TraceCheckUtils]: 16: Hoare triple {9266#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9267#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:28,681 INFO L273 TraceCheckUtils]: 17: Hoare triple {9267#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9268#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:28,682 INFO L273 TraceCheckUtils]: 18: Hoare triple {9268#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9269#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:28,683 INFO L273 TraceCheckUtils]: 19: Hoare triple {9269#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9270#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:28,684 INFO L273 TraceCheckUtils]: 20: Hoare triple {9270#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9271#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:28,685 INFO L273 TraceCheckUtils]: 21: Hoare triple {9271#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9272#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:28,686 INFO L273 TraceCheckUtils]: 22: Hoare triple {9272#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9273#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:28,688 INFO L273 TraceCheckUtils]: 23: Hoare triple {9273#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9274#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:28,689 INFO L273 TraceCheckUtils]: 24: Hoare triple {9274#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9275#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:28,690 INFO L273 TraceCheckUtils]: 25: Hoare triple {9275#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9276#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:28,691 INFO L273 TraceCheckUtils]: 26: Hoare triple {9276#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9277#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:28,692 INFO L273 TraceCheckUtils]: 27: Hoare triple {9277#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9278#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:28,693 INFO L273 TraceCheckUtils]: 28: Hoare triple {9278#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9279#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:28,694 INFO L273 TraceCheckUtils]: 29: Hoare triple {9279#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9280#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:28,695 INFO L273 TraceCheckUtils]: 30: Hoare triple {9280#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9281#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:28,696 INFO L273 TraceCheckUtils]: 31: Hoare triple {9281#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9282#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:28,697 INFO L273 TraceCheckUtils]: 32: Hoare triple {9282#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9283#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:28,700 INFO L273 TraceCheckUtils]: 33: Hoare triple {9283#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9284#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:28,701 INFO L273 TraceCheckUtils]: 34: Hoare triple {9284#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9285#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:28,702 INFO L273 TraceCheckUtils]: 35: Hoare triple {9285#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9286#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:28,702 INFO L273 TraceCheckUtils]: 36: Hoare triple {9286#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9287#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:28,703 INFO L273 TraceCheckUtils]: 37: Hoare triple {9287#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9288#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:28,703 INFO L273 TraceCheckUtils]: 38: Hoare triple {9288#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9289#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:28,704 INFO L273 TraceCheckUtils]: 39: Hoare triple {9289#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9290#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:28,705 INFO L273 TraceCheckUtils]: 40: Hoare triple {9290#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9291#(<= main_~i~0 35)} is VALID [2018-11-23 12:10:28,706 INFO L273 TraceCheckUtils]: 41: Hoare triple {9291#(<= main_~i~0 35)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9292#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:28,707 INFO L273 TraceCheckUtils]: 42: Hoare triple {9292#(<= main_~i~0 36)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9293#(<= main_~i~0 37)} is VALID [2018-11-23 12:10:28,708 INFO L273 TraceCheckUtils]: 43: Hoare triple {9293#(<= main_~i~0 37)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9294#(<= main_~i~0 38)} is VALID [2018-11-23 12:10:28,709 INFO L273 TraceCheckUtils]: 44: Hoare triple {9294#(<= main_~i~0 38)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9295#(<= main_~i~0 39)} is VALID [2018-11-23 12:10:28,710 INFO L273 TraceCheckUtils]: 45: Hoare triple {9295#(<= main_~i~0 39)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9296#(<= main_~i~0 40)} is VALID [2018-11-23 12:10:28,710 INFO L273 TraceCheckUtils]: 46: Hoare triple {9296#(<= main_~i~0 40)} assume !(~i~0 < 100000); {9255#false} is VALID [2018-11-23 12:10:28,711 INFO L273 TraceCheckUtils]: 47: Hoare triple {9255#false} ~i~0 := 1; {9255#false} is VALID [2018-11-23 12:10:28,711 INFO L273 TraceCheckUtils]: 48: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,711 INFO L273 TraceCheckUtils]: 49: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,711 INFO L273 TraceCheckUtils]: 50: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,712 INFO L273 TraceCheckUtils]: 51: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,712 INFO L273 TraceCheckUtils]: 52: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,712 INFO L273 TraceCheckUtils]: 53: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,712 INFO L273 TraceCheckUtils]: 54: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,712 INFO L273 TraceCheckUtils]: 55: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9255#false} is VALID [2018-11-23 12:10:28,713 INFO L273 TraceCheckUtils]: 56: Hoare triple {9255#false} assume !(~i~0 < 100000); {9255#false} is VALID [2018-11-23 12:10:28,713 INFO L273 TraceCheckUtils]: 57: Hoare triple {9255#false} ~i~0 := 1;~j~0 := 0; {9255#false} is VALID [2018-11-23 12:10:28,713 INFO L273 TraceCheckUtils]: 58: Hoare triple {9255#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {9255#false} is VALID [2018-11-23 12:10:28,713 INFO L256 TraceCheckUtils]: 59: Hoare triple {9255#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {9255#false} is VALID [2018-11-23 12:10:28,713 INFO L273 TraceCheckUtils]: 60: Hoare triple {9255#false} ~cond := #in~cond; {9255#false} is VALID [2018-11-23 12:10:28,713 INFO L273 TraceCheckUtils]: 61: Hoare triple {9255#false} assume 0 == ~cond; {9255#false} is VALID [2018-11-23 12:10:28,714 INFO L273 TraceCheckUtils]: 62: Hoare triple {9255#false} assume !false; {9255#false} is VALID [2018-11-23 12:10:28,717 INFO L134 CoverageAnalysis]: Checked inductivity of 856 backedges. 0 proven. 820 refuted. 0 times theorem prover too weak. 36 trivial. 0 not checked. [2018-11-23 12:10:28,736 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:28,736 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [43, 43] total 44 [2018-11-23 12:10:28,736 INFO L78 Accepts]: Start accepts. Automaton has 44 states. Word has length 63 [2018-11-23 12:10:28,737 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:28,737 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 44 states. [2018-11-23 12:10:28,783 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 58 edges. 58 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:28,783 INFO L459 AbstractCegarLoop]: Interpolant automaton has 44 states [2018-11-23 12:10:28,783 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 44 interpolants. [2018-11-23 12:10:28,784 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=946, Invalid=946, Unknown=0, NotChecked=0, Total=1892 [2018-11-23 12:10:28,785 INFO L87 Difference]: Start difference. First operand 67 states and 69 transitions. Second operand 44 states. [2018-11-23 12:10:29,717 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:29,718 INFO L93 Difference]: Finished difference Result 103 states and 112 transitions. [2018-11-23 12:10:29,718 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 43 states. [2018-11-23 12:10:29,718 INFO L78 Accepts]: Start accepts. Automaton has 44 states. Word has length 63 [2018-11-23 12:10:29,718 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:29,718 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 44 states. [2018-11-23 12:10:29,720 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 43 states to 43 states and 101 transitions. [2018-11-23 12:10:29,720 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 44 states. [2018-11-23 12:10:29,722 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 43 states to 43 states and 101 transitions. [2018-11-23 12:10:29,722 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 43 states and 101 transitions. [2018-11-23 12:10:30,335 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 101 edges. 101 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:30,337 INFO L225 Difference]: With dead ends: 103 [2018-11-23 12:10:30,337 INFO L226 Difference]: Without dead ends: 83 [2018-11-23 12:10:30,338 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 105 GetRequests, 63 SyntacticMatches, 0 SemanticMatches, 42 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 78 ImplicationChecksByTransitivity, 0.7s TimeCoverageRelationStatistics Valid=946, Invalid=946, Unknown=0, NotChecked=0, Total=1892 [2018-11-23 12:10:30,338 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 83 states. [2018-11-23 12:10:31,701 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 83 to 68. [2018-11-23 12:10:31,701 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:31,701 INFO L82 GeneralOperation]: Start isEquivalent. First operand 83 states. Second operand 68 states. [2018-11-23 12:10:31,701 INFO L74 IsIncluded]: Start isIncluded. First operand 83 states. Second operand 68 states. [2018-11-23 12:10:31,702 INFO L87 Difference]: Start difference. First operand 83 states. Second operand 68 states. [2018-11-23 12:10:31,703 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:31,704 INFO L93 Difference]: Finished difference Result 83 states and 90 transitions. [2018-11-23 12:10:31,704 INFO L276 IsEmpty]: Start isEmpty. Operand 83 states and 90 transitions. [2018-11-23 12:10:31,704 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:31,704 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:31,704 INFO L74 IsIncluded]: Start isIncluded. First operand 68 states. Second operand 83 states. [2018-11-23 12:10:31,705 INFO L87 Difference]: Start difference. First operand 68 states. Second operand 83 states. [2018-11-23 12:10:31,706 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:31,706 INFO L93 Difference]: Finished difference Result 83 states and 90 transitions. [2018-11-23 12:10:31,707 INFO L276 IsEmpty]: Start isEmpty. Operand 83 states and 90 transitions. [2018-11-23 12:10:31,707 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:31,707 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:31,707 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:31,707 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:31,708 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 68 states. [2018-11-23 12:10:31,709 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 68 states to 68 states and 70 transitions. [2018-11-23 12:10:31,709 INFO L78 Accepts]: Start accepts. Automaton has 68 states and 70 transitions. Word has length 63 [2018-11-23 12:10:31,709 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:31,709 INFO L480 AbstractCegarLoop]: Abstraction has 68 states and 70 transitions. [2018-11-23 12:10:31,709 INFO L481 AbstractCegarLoop]: Interpolant automaton has 44 states. [2018-11-23 12:10:31,709 INFO L276 IsEmpty]: Start isEmpty. Operand 68 states and 70 transitions. [2018-11-23 12:10:31,710 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 65 [2018-11-23 12:10:31,710 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:31,710 INFO L402 BasicCegarLoop]: trace histogram [41, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:31,710 INFO L423 AbstractCegarLoop]: === Iteration 26 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:31,711 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:31,711 INFO L82 PathProgramCache]: Analyzing trace with hash 1545954122, now seen corresponding path program 23 times [2018-11-23 12:10:31,711 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:31,711 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:31,712 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:31,712 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:31,712 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:31,758 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:33,925 INFO L256 TraceCheckUtils]: 0: Hoare triple {9961#true} call ULTIMATE.init(); {9961#true} is VALID [2018-11-23 12:10:33,925 INFO L273 TraceCheckUtils]: 1: Hoare triple {9961#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {9961#true} is VALID [2018-11-23 12:10:33,925 INFO L273 TraceCheckUtils]: 2: Hoare triple {9961#true} assume true; {9961#true} is VALID [2018-11-23 12:10:33,926 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {9961#true} {9961#true} #60#return; {9961#true} is VALID [2018-11-23 12:10:33,926 INFO L256 TraceCheckUtils]: 4: Hoare triple {9961#true} call #t~ret4 := main(); {9961#true} is VALID [2018-11-23 12:10:33,926 INFO L273 TraceCheckUtils]: 5: Hoare triple {9961#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {9963#(= main_~i~0 0)} is VALID [2018-11-23 12:10:33,927 INFO L273 TraceCheckUtils]: 6: Hoare triple {9963#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9964#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:33,928 INFO L273 TraceCheckUtils]: 7: Hoare triple {9964#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9965#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:33,929 INFO L273 TraceCheckUtils]: 8: Hoare triple {9965#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9966#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:33,929 INFO L273 TraceCheckUtils]: 9: Hoare triple {9966#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9967#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:33,930 INFO L273 TraceCheckUtils]: 10: Hoare triple {9967#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9968#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:33,930 INFO L273 TraceCheckUtils]: 11: Hoare triple {9968#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9969#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:33,931 INFO L273 TraceCheckUtils]: 12: Hoare triple {9969#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9970#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:33,932 INFO L273 TraceCheckUtils]: 13: Hoare triple {9970#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9971#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:33,933 INFO L273 TraceCheckUtils]: 14: Hoare triple {9971#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9972#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:33,934 INFO L273 TraceCheckUtils]: 15: Hoare triple {9972#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9973#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:33,935 INFO L273 TraceCheckUtils]: 16: Hoare triple {9973#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9974#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:33,936 INFO L273 TraceCheckUtils]: 17: Hoare triple {9974#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9975#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:33,937 INFO L273 TraceCheckUtils]: 18: Hoare triple {9975#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9976#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:33,938 INFO L273 TraceCheckUtils]: 19: Hoare triple {9976#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9977#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:33,939 INFO L273 TraceCheckUtils]: 20: Hoare triple {9977#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9978#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:33,940 INFO L273 TraceCheckUtils]: 21: Hoare triple {9978#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9979#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:33,941 INFO L273 TraceCheckUtils]: 22: Hoare triple {9979#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9980#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:33,942 INFO L273 TraceCheckUtils]: 23: Hoare triple {9980#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9981#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:33,943 INFO L273 TraceCheckUtils]: 24: Hoare triple {9981#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9982#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:33,944 INFO L273 TraceCheckUtils]: 25: Hoare triple {9982#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9983#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:33,945 INFO L273 TraceCheckUtils]: 26: Hoare triple {9983#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9984#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:33,946 INFO L273 TraceCheckUtils]: 27: Hoare triple {9984#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9985#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:33,947 INFO L273 TraceCheckUtils]: 28: Hoare triple {9985#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9986#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:33,948 INFO L273 TraceCheckUtils]: 29: Hoare triple {9986#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9987#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:33,949 INFO L273 TraceCheckUtils]: 30: Hoare triple {9987#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9988#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:33,950 INFO L273 TraceCheckUtils]: 31: Hoare triple {9988#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9989#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:33,951 INFO L273 TraceCheckUtils]: 32: Hoare triple {9989#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9990#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:33,952 INFO L273 TraceCheckUtils]: 33: Hoare triple {9990#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9991#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:33,956 INFO L273 TraceCheckUtils]: 34: Hoare triple {9991#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9992#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:33,957 INFO L273 TraceCheckUtils]: 35: Hoare triple {9992#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9993#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:33,958 INFO L273 TraceCheckUtils]: 36: Hoare triple {9993#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9994#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:33,958 INFO L273 TraceCheckUtils]: 37: Hoare triple {9994#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9995#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:33,959 INFO L273 TraceCheckUtils]: 38: Hoare triple {9995#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9996#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:33,961 INFO L273 TraceCheckUtils]: 39: Hoare triple {9996#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9997#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:33,962 INFO L273 TraceCheckUtils]: 40: Hoare triple {9997#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9998#(<= main_~i~0 35)} is VALID [2018-11-23 12:10:33,963 INFO L273 TraceCheckUtils]: 41: Hoare triple {9998#(<= main_~i~0 35)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9999#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:33,964 INFO L273 TraceCheckUtils]: 42: Hoare triple {9999#(<= main_~i~0 36)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10000#(<= main_~i~0 37)} is VALID [2018-11-23 12:10:33,964 INFO L273 TraceCheckUtils]: 43: Hoare triple {10000#(<= main_~i~0 37)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10001#(<= main_~i~0 38)} is VALID [2018-11-23 12:10:33,966 INFO L273 TraceCheckUtils]: 44: Hoare triple {10001#(<= main_~i~0 38)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10002#(<= main_~i~0 39)} is VALID [2018-11-23 12:10:33,967 INFO L273 TraceCheckUtils]: 45: Hoare triple {10002#(<= main_~i~0 39)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10003#(<= main_~i~0 40)} is VALID [2018-11-23 12:10:33,968 INFO L273 TraceCheckUtils]: 46: Hoare triple {10003#(<= main_~i~0 40)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10004#(<= main_~i~0 41)} is VALID [2018-11-23 12:10:33,968 INFO L273 TraceCheckUtils]: 47: Hoare triple {10004#(<= main_~i~0 41)} assume !(~i~0 < 100000); {9962#false} is VALID [2018-11-23 12:10:33,969 INFO L273 TraceCheckUtils]: 48: Hoare triple {9962#false} ~i~0 := 1; {9962#false} is VALID [2018-11-23 12:10:33,969 INFO L273 TraceCheckUtils]: 49: Hoare triple {9962#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9962#false} is VALID [2018-11-23 12:10:33,969 INFO L273 TraceCheckUtils]: 50: Hoare triple {9962#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9962#false} is VALID [2018-11-23 12:10:33,969 INFO L273 TraceCheckUtils]: 51: Hoare triple {9962#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9962#false} is VALID [2018-11-23 12:10:33,969 INFO L273 TraceCheckUtils]: 52: Hoare triple {9962#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9962#false} is VALID [2018-11-23 12:10:33,970 INFO L273 TraceCheckUtils]: 53: Hoare triple {9962#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9962#false} is VALID [2018-11-23 12:10:33,970 INFO L273 TraceCheckUtils]: 54: Hoare triple {9962#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9962#false} is VALID [2018-11-23 12:10:33,970 INFO L273 TraceCheckUtils]: 55: Hoare triple {9962#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9962#false} is VALID [2018-11-23 12:10:33,970 INFO L273 TraceCheckUtils]: 56: Hoare triple {9962#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9962#false} is VALID [2018-11-23 12:10:33,970 INFO L273 TraceCheckUtils]: 57: Hoare triple {9962#false} assume !(~i~0 < 100000); {9962#false} is VALID [2018-11-23 12:10:33,971 INFO L273 TraceCheckUtils]: 58: Hoare triple {9962#false} ~i~0 := 1;~j~0 := 0; {9962#false} is VALID [2018-11-23 12:10:33,971 INFO L273 TraceCheckUtils]: 59: Hoare triple {9962#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {9962#false} is VALID [2018-11-23 12:10:33,971 INFO L256 TraceCheckUtils]: 60: Hoare triple {9962#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {9962#false} is VALID [2018-11-23 12:10:33,971 INFO L273 TraceCheckUtils]: 61: Hoare triple {9962#false} ~cond := #in~cond; {9962#false} is VALID [2018-11-23 12:10:33,971 INFO L273 TraceCheckUtils]: 62: Hoare triple {9962#false} assume 0 == ~cond; {9962#false} is VALID [2018-11-23 12:10:33,972 INFO L273 TraceCheckUtils]: 63: Hoare triple {9962#false} assume !false; {9962#false} is VALID [2018-11-23 12:10:33,975 INFO L134 CoverageAnalysis]: Checked inductivity of 897 backedges. 0 proven. 861 refuted. 0 times theorem prover too weak. 36 trivial. 0 not checked. [2018-11-23 12:10:33,975 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:33,975 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 24 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 24 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:33,984 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:11:12,509 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 22 check-sat command(s) [2018-11-23 12:11:12,510 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:11:12,552 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:12,553 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:11:12,764 INFO L256 TraceCheckUtils]: 0: Hoare triple {9961#true} call ULTIMATE.init(); {9961#true} is VALID [2018-11-23 12:11:12,765 INFO L273 TraceCheckUtils]: 1: Hoare triple {9961#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {9961#true} is VALID [2018-11-23 12:11:12,765 INFO L273 TraceCheckUtils]: 2: Hoare triple {9961#true} assume true; {9961#true} is VALID [2018-11-23 12:11:12,765 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {9961#true} {9961#true} #60#return; {9961#true} is VALID [2018-11-23 12:11:12,765 INFO L256 TraceCheckUtils]: 4: Hoare triple {9961#true} call #t~ret4 := main(); {9961#true} is VALID [2018-11-23 12:11:12,765 INFO L273 TraceCheckUtils]: 5: Hoare triple {9961#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {9961#true} is VALID [2018-11-23 12:11:12,766 INFO L273 TraceCheckUtils]: 6: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,766 INFO L273 TraceCheckUtils]: 7: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,766 INFO L273 TraceCheckUtils]: 8: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,766 INFO L273 TraceCheckUtils]: 9: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,766 INFO L273 TraceCheckUtils]: 10: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,767 INFO L273 TraceCheckUtils]: 11: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,767 INFO L273 TraceCheckUtils]: 12: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,767 INFO L273 TraceCheckUtils]: 13: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,767 INFO L273 TraceCheckUtils]: 14: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,767 INFO L273 TraceCheckUtils]: 15: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,768 INFO L273 TraceCheckUtils]: 16: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,768 INFO L273 TraceCheckUtils]: 17: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,768 INFO L273 TraceCheckUtils]: 18: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,768 INFO L273 TraceCheckUtils]: 19: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,768 INFO L273 TraceCheckUtils]: 20: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,768 INFO L273 TraceCheckUtils]: 21: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,768 INFO L273 TraceCheckUtils]: 22: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,768 INFO L273 TraceCheckUtils]: 23: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,769 INFO L273 TraceCheckUtils]: 24: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,769 INFO L273 TraceCheckUtils]: 25: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,769 INFO L273 TraceCheckUtils]: 26: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,769 INFO L273 TraceCheckUtils]: 27: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,769 INFO L273 TraceCheckUtils]: 28: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,769 INFO L273 TraceCheckUtils]: 29: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,769 INFO L273 TraceCheckUtils]: 30: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,769 INFO L273 TraceCheckUtils]: 31: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,769 INFO L273 TraceCheckUtils]: 32: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,770 INFO L273 TraceCheckUtils]: 33: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,770 INFO L273 TraceCheckUtils]: 34: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,770 INFO L273 TraceCheckUtils]: 35: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,770 INFO L273 TraceCheckUtils]: 36: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,770 INFO L273 TraceCheckUtils]: 37: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,770 INFO L273 TraceCheckUtils]: 38: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,770 INFO L273 TraceCheckUtils]: 39: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,770 INFO L273 TraceCheckUtils]: 40: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,771 INFO L273 TraceCheckUtils]: 41: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,771 INFO L273 TraceCheckUtils]: 42: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,771 INFO L273 TraceCheckUtils]: 43: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,771 INFO L273 TraceCheckUtils]: 44: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,771 INFO L273 TraceCheckUtils]: 45: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,771 INFO L273 TraceCheckUtils]: 46: Hoare triple {9961#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {9961#true} is VALID [2018-11-23 12:11:12,771 INFO L273 TraceCheckUtils]: 47: Hoare triple {9961#true} assume !(~i~0 < 100000); {9961#true} is VALID [2018-11-23 12:11:12,772 INFO L273 TraceCheckUtils]: 48: Hoare triple {9961#true} ~i~0 := 1; {9964#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:12,772 INFO L273 TraceCheckUtils]: 49: Hoare triple {9964#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9973#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:12,773 INFO L273 TraceCheckUtils]: 50: Hoare triple {9973#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9982#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:12,774 INFO L273 TraceCheckUtils]: 51: Hoare triple {9982#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {9991#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:12,774 INFO L273 TraceCheckUtils]: 52: Hoare triple {9991#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10000#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:12,775 INFO L273 TraceCheckUtils]: 53: Hoare triple {10000#(<= main_~i~0 37)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10167#(<= main_~i~0 46)} is VALID [2018-11-23 12:11:12,775 INFO L273 TraceCheckUtils]: 54: Hoare triple {10167#(<= main_~i~0 46)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10171#(<= main_~i~0 55)} is VALID [2018-11-23 12:11:12,776 INFO L273 TraceCheckUtils]: 55: Hoare triple {10171#(<= main_~i~0 55)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10175#(<= main_~i~0 64)} is VALID [2018-11-23 12:11:12,777 INFO L273 TraceCheckUtils]: 56: Hoare triple {10175#(<= main_~i~0 64)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10179#(<= main_~i~0 73)} is VALID [2018-11-23 12:11:12,778 INFO L273 TraceCheckUtils]: 57: Hoare triple {10179#(<= main_~i~0 73)} assume !(~i~0 < 100000); {9962#false} is VALID [2018-11-23 12:11:12,778 INFO L273 TraceCheckUtils]: 58: Hoare triple {9962#false} ~i~0 := 1;~j~0 := 0; {9962#false} is VALID [2018-11-23 12:11:12,778 INFO L273 TraceCheckUtils]: 59: Hoare triple {9962#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {9962#false} is VALID [2018-11-23 12:11:12,778 INFO L256 TraceCheckUtils]: 60: Hoare triple {9962#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {9962#false} is VALID [2018-11-23 12:11:12,779 INFO L273 TraceCheckUtils]: 61: Hoare triple {9962#false} ~cond := #in~cond; {9962#false} is VALID [2018-11-23 12:11:12,779 INFO L273 TraceCheckUtils]: 62: Hoare triple {9962#false} assume 0 == ~cond; {9962#false} is VALID [2018-11-23 12:11:12,779 INFO L273 TraceCheckUtils]: 63: Hoare triple {9962#false} assume !false; {9962#false} is VALID [2018-11-23 12:11:12,782 INFO L134 CoverageAnalysis]: Checked inductivity of 897 backedges. 0 proven. 36 refuted. 0 times theorem prover too weak. 861 trivial. 0 not checked. [2018-11-23 12:11:12,811 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:11:12,812 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [44, 11] total 48 [2018-11-23 12:11:12,812 INFO L78 Accepts]: Start accepts. Automaton has 48 states. Word has length 64 [2018-11-23 12:11:12,812 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:11:12,812 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 48 states. [2018-11-23 12:11:12,875 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 70 edges. 70 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:12,876 INFO L459 AbstractCegarLoop]: Interpolant automaton has 48 states [2018-11-23 12:11:12,876 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 48 interpolants. [2018-11-23 12:11:12,877 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1128, Invalid=1128, Unknown=0, NotChecked=0, Total=2256 [2018-11-23 12:11:12,878 INFO L87 Difference]: Start difference. First operand 68 states and 70 transitions. Second operand 48 states. [2018-11-23 12:11:15,077 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:15,078 INFO L93 Difference]: Finished difference Result 121 states and 139 transitions. [2018-11-23 12:11:15,078 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 48 states. [2018-11-23 12:11:15,078 INFO L78 Accepts]: Start accepts. Automaton has 48 states. Word has length 64 [2018-11-23 12:11:15,078 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:11:15,078 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 48 states. [2018-11-23 12:11:15,079 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 48 states to 48 states and 131 transitions. [2018-11-23 12:11:15,080 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 48 states. [2018-11-23 12:11:15,081 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 48 states to 48 states and 131 transitions. [2018-11-23 12:11:15,081 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 48 states and 131 transitions. [2018-11-23 12:11:15,274 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 131 edges. 131 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:15,276 INFO L225 Difference]: With dead ends: 121 [2018-11-23 12:11:15,276 INFO L226 Difference]: Without dead ends: 101 [2018-11-23 12:11:15,277 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 107 GetRequests, 61 SyntacticMatches, 0 SemanticMatches, 46 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 1.9s TimeCoverageRelationStatistics Valid=1128, Invalid=1128, Unknown=0, NotChecked=0, Total=2256 [2018-11-23 12:11:15,277 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 101 states. [2018-11-23 12:11:15,336 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 101 to 74. [2018-11-23 12:11:15,336 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:11:15,337 INFO L82 GeneralOperation]: Start isEquivalent. First operand 101 states. Second operand 74 states. [2018-11-23 12:11:15,337 INFO L74 IsIncluded]: Start isIncluded. First operand 101 states. Second operand 74 states. [2018-11-23 12:11:15,337 INFO L87 Difference]: Start difference. First operand 101 states. Second operand 74 states. [2018-11-23 12:11:15,339 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:15,339 INFO L93 Difference]: Finished difference Result 101 states and 112 transitions. [2018-11-23 12:11:15,339 INFO L276 IsEmpty]: Start isEmpty. Operand 101 states and 112 transitions. [2018-11-23 12:11:15,339 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:15,340 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:15,340 INFO L74 IsIncluded]: Start isIncluded. First operand 74 states. Second operand 101 states. [2018-11-23 12:11:15,340 INFO L87 Difference]: Start difference. First operand 74 states. Second operand 101 states. [2018-11-23 12:11:15,342 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:15,342 INFO L93 Difference]: Finished difference Result 101 states and 112 transitions. [2018-11-23 12:11:15,342 INFO L276 IsEmpty]: Start isEmpty. Operand 101 states and 112 transitions. [2018-11-23 12:11:15,343 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:15,343 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:15,343 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:11:15,343 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:11:15,343 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 74 states. [2018-11-23 12:11:15,344 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 74 states to 74 states and 76 transitions. [2018-11-23 12:11:15,345 INFO L78 Accepts]: Start accepts. Automaton has 74 states and 76 transitions. Word has length 64 [2018-11-23 12:11:15,345 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:11:15,345 INFO L480 AbstractCegarLoop]: Abstraction has 74 states and 76 transitions. [2018-11-23 12:11:15,345 INFO L481 AbstractCegarLoop]: Interpolant automaton has 48 states. [2018-11-23 12:11:15,345 INFO L276 IsEmpty]: Start isEmpty. Operand 74 states and 76 transitions. [2018-11-23 12:11:15,346 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 71 [2018-11-23 12:11:15,346 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:11:15,346 INFO L402 BasicCegarLoop]: trace histogram [46, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:11:15,346 INFO L423 AbstractCegarLoop]: === Iteration 27 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:11:15,346 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:11:15,346 INFO L82 PathProgramCache]: Analyzing trace with hash -492952983, now seen corresponding path program 24 times [2018-11-23 12:11:15,347 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:11:15,347 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:11:15,347 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:15,347 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:11:15,347 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:15,397 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:16,477 INFO L256 TraceCheckUtils]: 0: Hoare triple {10755#true} call ULTIMATE.init(); {10755#true} is VALID [2018-11-23 12:11:16,477 INFO L273 TraceCheckUtils]: 1: Hoare triple {10755#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {10755#true} is VALID [2018-11-23 12:11:16,477 INFO L273 TraceCheckUtils]: 2: Hoare triple {10755#true} assume true; {10755#true} is VALID [2018-11-23 12:11:16,477 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {10755#true} {10755#true} #60#return; {10755#true} is VALID [2018-11-23 12:11:16,477 INFO L256 TraceCheckUtils]: 4: Hoare triple {10755#true} call #t~ret4 := main(); {10755#true} is VALID [2018-11-23 12:11:16,478 INFO L273 TraceCheckUtils]: 5: Hoare triple {10755#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {10757#(= main_~i~0 0)} is VALID [2018-11-23 12:11:16,478 INFO L273 TraceCheckUtils]: 6: Hoare triple {10757#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10758#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:16,479 INFO L273 TraceCheckUtils]: 7: Hoare triple {10758#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10759#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:16,480 INFO L273 TraceCheckUtils]: 8: Hoare triple {10759#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10760#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:16,481 INFO L273 TraceCheckUtils]: 9: Hoare triple {10760#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10761#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:16,482 INFO L273 TraceCheckUtils]: 10: Hoare triple {10761#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10762#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:16,483 INFO L273 TraceCheckUtils]: 11: Hoare triple {10762#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10763#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:16,484 INFO L273 TraceCheckUtils]: 12: Hoare triple {10763#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10764#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:16,485 INFO L273 TraceCheckUtils]: 13: Hoare triple {10764#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10765#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:16,486 INFO L273 TraceCheckUtils]: 14: Hoare triple {10765#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10766#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:16,487 INFO L273 TraceCheckUtils]: 15: Hoare triple {10766#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10767#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:16,488 INFO L273 TraceCheckUtils]: 16: Hoare triple {10767#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10768#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:16,489 INFO L273 TraceCheckUtils]: 17: Hoare triple {10768#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10769#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:16,490 INFO L273 TraceCheckUtils]: 18: Hoare triple {10769#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10770#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:16,491 INFO L273 TraceCheckUtils]: 19: Hoare triple {10770#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10771#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:16,492 INFO L273 TraceCheckUtils]: 20: Hoare triple {10771#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10772#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:16,493 INFO L273 TraceCheckUtils]: 21: Hoare triple {10772#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10773#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:16,494 INFO L273 TraceCheckUtils]: 22: Hoare triple {10773#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10774#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:16,495 INFO L273 TraceCheckUtils]: 23: Hoare triple {10774#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10775#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:16,496 INFO L273 TraceCheckUtils]: 24: Hoare triple {10775#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10776#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:16,497 INFO L273 TraceCheckUtils]: 25: Hoare triple {10776#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10777#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:16,498 INFO L273 TraceCheckUtils]: 26: Hoare triple {10777#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10778#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:16,499 INFO L273 TraceCheckUtils]: 27: Hoare triple {10778#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10779#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:16,500 INFO L273 TraceCheckUtils]: 28: Hoare triple {10779#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10780#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:16,501 INFO L273 TraceCheckUtils]: 29: Hoare triple {10780#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10781#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:16,502 INFO L273 TraceCheckUtils]: 30: Hoare triple {10781#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10782#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:16,503 INFO L273 TraceCheckUtils]: 31: Hoare triple {10782#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10783#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:16,504 INFO L273 TraceCheckUtils]: 32: Hoare triple {10783#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10784#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:16,505 INFO L273 TraceCheckUtils]: 33: Hoare triple {10784#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10785#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:16,506 INFO L273 TraceCheckUtils]: 34: Hoare triple {10785#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10786#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:16,507 INFO L273 TraceCheckUtils]: 35: Hoare triple {10786#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10787#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:16,508 INFO L273 TraceCheckUtils]: 36: Hoare triple {10787#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10788#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:16,509 INFO L273 TraceCheckUtils]: 37: Hoare triple {10788#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10789#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:16,510 INFO L273 TraceCheckUtils]: 38: Hoare triple {10789#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10790#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:16,511 INFO L273 TraceCheckUtils]: 39: Hoare triple {10790#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10791#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:16,512 INFO L273 TraceCheckUtils]: 40: Hoare triple {10791#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10792#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:16,513 INFO L273 TraceCheckUtils]: 41: Hoare triple {10792#(<= main_~i~0 35)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10793#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:16,514 INFO L273 TraceCheckUtils]: 42: Hoare triple {10793#(<= main_~i~0 36)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10794#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:16,515 INFO L273 TraceCheckUtils]: 43: Hoare triple {10794#(<= main_~i~0 37)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10795#(<= main_~i~0 38)} is VALID [2018-11-23 12:11:16,516 INFO L273 TraceCheckUtils]: 44: Hoare triple {10795#(<= main_~i~0 38)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10796#(<= main_~i~0 39)} is VALID [2018-11-23 12:11:16,517 INFO L273 TraceCheckUtils]: 45: Hoare triple {10796#(<= main_~i~0 39)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10797#(<= main_~i~0 40)} is VALID [2018-11-23 12:11:16,518 INFO L273 TraceCheckUtils]: 46: Hoare triple {10797#(<= main_~i~0 40)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10798#(<= main_~i~0 41)} is VALID [2018-11-23 12:11:16,519 INFO L273 TraceCheckUtils]: 47: Hoare triple {10798#(<= main_~i~0 41)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10799#(<= main_~i~0 42)} is VALID [2018-11-23 12:11:16,520 INFO L273 TraceCheckUtils]: 48: Hoare triple {10799#(<= main_~i~0 42)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10800#(<= main_~i~0 43)} is VALID [2018-11-23 12:11:16,521 INFO L273 TraceCheckUtils]: 49: Hoare triple {10800#(<= main_~i~0 43)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10801#(<= main_~i~0 44)} is VALID [2018-11-23 12:11:16,522 INFO L273 TraceCheckUtils]: 50: Hoare triple {10801#(<= main_~i~0 44)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10802#(<= main_~i~0 45)} is VALID [2018-11-23 12:11:16,523 INFO L273 TraceCheckUtils]: 51: Hoare triple {10802#(<= main_~i~0 45)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10803#(<= main_~i~0 46)} is VALID [2018-11-23 12:11:16,524 INFO L273 TraceCheckUtils]: 52: Hoare triple {10803#(<= main_~i~0 46)} assume !(~i~0 < 100000); {10756#false} is VALID [2018-11-23 12:11:16,524 INFO L273 TraceCheckUtils]: 53: Hoare triple {10756#false} ~i~0 := 1; {10756#false} is VALID [2018-11-23 12:11:16,524 INFO L273 TraceCheckUtils]: 54: Hoare triple {10756#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10756#false} is VALID [2018-11-23 12:11:16,524 INFO L273 TraceCheckUtils]: 55: Hoare triple {10756#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10756#false} is VALID [2018-11-23 12:11:16,525 INFO L273 TraceCheckUtils]: 56: Hoare triple {10756#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10756#false} is VALID [2018-11-23 12:11:16,525 INFO L273 TraceCheckUtils]: 57: Hoare triple {10756#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10756#false} is VALID [2018-11-23 12:11:16,525 INFO L273 TraceCheckUtils]: 58: Hoare triple {10756#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10756#false} is VALID [2018-11-23 12:11:16,525 INFO L273 TraceCheckUtils]: 59: Hoare triple {10756#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10756#false} is VALID [2018-11-23 12:11:16,525 INFO L273 TraceCheckUtils]: 60: Hoare triple {10756#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10756#false} is VALID [2018-11-23 12:11:16,526 INFO L273 TraceCheckUtils]: 61: Hoare triple {10756#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10756#false} is VALID [2018-11-23 12:11:16,526 INFO L273 TraceCheckUtils]: 62: Hoare triple {10756#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10756#false} is VALID [2018-11-23 12:11:16,526 INFO L273 TraceCheckUtils]: 63: Hoare triple {10756#false} assume !(~i~0 < 100000); {10756#false} is VALID [2018-11-23 12:11:16,526 INFO L273 TraceCheckUtils]: 64: Hoare triple {10756#false} ~i~0 := 1;~j~0 := 0; {10756#false} is VALID [2018-11-23 12:11:16,526 INFO L273 TraceCheckUtils]: 65: Hoare triple {10756#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {10756#false} is VALID [2018-11-23 12:11:16,527 INFO L256 TraceCheckUtils]: 66: Hoare triple {10756#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {10756#false} is VALID [2018-11-23 12:11:16,527 INFO L273 TraceCheckUtils]: 67: Hoare triple {10756#false} ~cond := #in~cond; {10756#false} is VALID [2018-11-23 12:11:16,527 INFO L273 TraceCheckUtils]: 68: Hoare triple {10756#false} assume 0 == ~cond; {10756#false} is VALID [2018-11-23 12:11:16,527 INFO L273 TraceCheckUtils]: 69: Hoare triple {10756#false} assume !false; {10756#false} is VALID [2018-11-23 12:11:16,532 INFO L134 CoverageAnalysis]: Checked inductivity of 1126 backedges. 0 proven. 1081 refuted. 0 times theorem prover too weak. 45 trivial. 0 not checked. [2018-11-23 12:11:16,532 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:11:16,532 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 25 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 25 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:11:16,542 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE [2018-11-23 12:11:20,788 INFO L249 tOrderPrioritization]: Assert order MIX_INSIDE_OUTSIDE issued 11 check-sat command(s) [2018-11-23 12:11:20,789 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:11:20,826 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:20,827 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:11:21,158 INFO L256 TraceCheckUtils]: 0: Hoare triple {10755#true} call ULTIMATE.init(); {10755#true} is VALID [2018-11-23 12:11:21,159 INFO L273 TraceCheckUtils]: 1: Hoare triple {10755#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {10755#true} is VALID [2018-11-23 12:11:21,159 INFO L273 TraceCheckUtils]: 2: Hoare triple {10755#true} assume true; {10755#true} is VALID [2018-11-23 12:11:21,159 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {10755#true} {10755#true} #60#return; {10755#true} is VALID [2018-11-23 12:11:21,160 INFO L256 TraceCheckUtils]: 4: Hoare triple {10755#true} call #t~ret4 := main(); {10755#true} is VALID [2018-11-23 12:11:21,160 INFO L273 TraceCheckUtils]: 5: Hoare triple {10755#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {10755#true} is VALID [2018-11-23 12:11:21,160 INFO L273 TraceCheckUtils]: 6: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,160 INFO L273 TraceCheckUtils]: 7: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,161 INFO L273 TraceCheckUtils]: 8: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,161 INFO L273 TraceCheckUtils]: 9: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,161 INFO L273 TraceCheckUtils]: 10: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,161 INFO L273 TraceCheckUtils]: 11: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,161 INFO L273 TraceCheckUtils]: 12: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,161 INFO L273 TraceCheckUtils]: 13: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,162 INFO L273 TraceCheckUtils]: 14: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,162 INFO L273 TraceCheckUtils]: 15: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,162 INFO L273 TraceCheckUtils]: 16: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,162 INFO L273 TraceCheckUtils]: 17: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,162 INFO L273 TraceCheckUtils]: 18: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,162 INFO L273 TraceCheckUtils]: 19: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,162 INFO L273 TraceCheckUtils]: 20: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,163 INFO L273 TraceCheckUtils]: 21: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,163 INFO L273 TraceCheckUtils]: 22: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,163 INFO L273 TraceCheckUtils]: 23: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,163 INFO L273 TraceCheckUtils]: 24: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,163 INFO L273 TraceCheckUtils]: 25: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,163 INFO L273 TraceCheckUtils]: 26: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,163 INFO L273 TraceCheckUtils]: 27: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,164 INFO L273 TraceCheckUtils]: 28: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,164 INFO L273 TraceCheckUtils]: 29: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,164 INFO L273 TraceCheckUtils]: 30: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,164 INFO L273 TraceCheckUtils]: 31: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,164 INFO L273 TraceCheckUtils]: 32: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,164 INFO L273 TraceCheckUtils]: 33: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,165 INFO L273 TraceCheckUtils]: 34: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,165 INFO L273 TraceCheckUtils]: 35: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,165 INFO L273 TraceCheckUtils]: 36: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,165 INFO L273 TraceCheckUtils]: 37: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,165 INFO L273 TraceCheckUtils]: 38: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,165 INFO L273 TraceCheckUtils]: 39: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,165 INFO L273 TraceCheckUtils]: 40: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,166 INFO L273 TraceCheckUtils]: 41: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,166 INFO L273 TraceCheckUtils]: 42: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,166 INFO L273 TraceCheckUtils]: 43: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,166 INFO L273 TraceCheckUtils]: 44: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,166 INFO L273 TraceCheckUtils]: 45: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,166 INFO L273 TraceCheckUtils]: 46: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,166 INFO L273 TraceCheckUtils]: 47: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,167 INFO L273 TraceCheckUtils]: 48: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,167 INFO L273 TraceCheckUtils]: 49: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,167 INFO L273 TraceCheckUtils]: 50: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,167 INFO L273 TraceCheckUtils]: 51: Hoare triple {10755#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10755#true} is VALID [2018-11-23 12:11:21,167 INFO L273 TraceCheckUtils]: 52: Hoare triple {10755#true} assume !(~i~0 < 100000); {10755#true} is VALID [2018-11-23 12:11:21,168 INFO L273 TraceCheckUtils]: 53: Hoare triple {10755#true} ~i~0 := 1; {10758#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:21,169 INFO L273 TraceCheckUtils]: 54: Hoare triple {10758#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10767#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:21,169 INFO L273 TraceCheckUtils]: 55: Hoare triple {10767#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10776#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:21,170 INFO L273 TraceCheckUtils]: 56: Hoare triple {10776#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10785#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:21,171 INFO L273 TraceCheckUtils]: 57: Hoare triple {10785#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10794#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:21,172 INFO L273 TraceCheckUtils]: 58: Hoare triple {10794#(<= main_~i~0 37)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10803#(<= main_~i~0 46)} is VALID [2018-11-23 12:11:21,173 INFO L273 TraceCheckUtils]: 59: Hoare triple {10803#(<= main_~i~0 46)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10984#(<= main_~i~0 55)} is VALID [2018-11-23 12:11:21,174 INFO L273 TraceCheckUtils]: 60: Hoare triple {10984#(<= main_~i~0 55)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10988#(<= main_~i~0 64)} is VALID [2018-11-23 12:11:21,175 INFO L273 TraceCheckUtils]: 61: Hoare triple {10988#(<= main_~i~0 64)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10992#(<= main_~i~0 73)} is VALID [2018-11-23 12:11:21,177 INFO L273 TraceCheckUtils]: 62: Hoare triple {10992#(<= main_~i~0 73)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {10996#(<= main_~i~0 82)} is VALID [2018-11-23 12:11:21,177 INFO L273 TraceCheckUtils]: 63: Hoare triple {10996#(<= main_~i~0 82)} assume !(~i~0 < 100000); {10756#false} is VALID [2018-11-23 12:11:21,178 INFO L273 TraceCheckUtils]: 64: Hoare triple {10756#false} ~i~0 := 1;~j~0 := 0; {10756#false} is VALID [2018-11-23 12:11:21,178 INFO L273 TraceCheckUtils]: 65: Hoare triple {10756#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {10756#false} is VALID [2018-11-23 12:11:21,178 INFO L256 TraceCheckUtils]: 66: Hoare triple {10756#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {10756#false} is VALID [2018-11-23 12:11:21,178 INFO L273 TraceCheckUtils]: 67: Hoare triple {10756#false} ~cond := #in~cond; {10756#false} is VALID [2018-11-23 12:11:21,179 INFO L273 TraceCheckUtils]: 68: Hoare triple {10756#false} assume 0 == ~cond; {10756#false} is VALID [2018-11-23 12:11:21,179 INFO L273 TraceCheckUtils]: 69: Hoare triple {10756#false} assume !false; {10756#false} is VALID [2018-11-23 12:11:21,185 INFO L134 CoverageAnalysis]: Checked inductivity of 1126 backedges. 0 proven. 45 refuted. 0 times theorem prover too weak. 1081 trivial. 0 not checked. [2018-11-23 12:11:21,206 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:11:21,206 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [49, 12] total 53 [2018-11-23 12:11:21,207 INFO L78 Accepts]: Start accepts. Automaton has 53 states. Word has length 70 [2018-11-23 12:11:21,207 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:11:21,207 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 53 states. [2018-11-23 12:11:21,279 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 76 edges. 76 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:21,279 INFO L459 AbstractCegarLoop]: Interpolant automaton has 53 states [2018-11-23 12:11:21,280 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 53 interpolants. [2018-11-23 12:11:21,282 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1378, Invalid=1378, Unknown=0, NotChecked=0, Total=2756 [2018-11-23 12:11:21,282 INFO L87 Difference]: Start difference. First operand 74 states and 76 transitions. Second operand 53 states. [2018-11-23 12:11:23,556 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:23,556 INFO L93 Difference]: Finished difference Result 131 states and 150 transitions. [2018-11-23 12:11:23,556 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 53 states. [2018-11-23 12:11:23,556 INFO L78 Accepts]: Start accepts. Automaton has 53 states. Word has length 70 [2018-11-23 12:11:23,556 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:11:23,557 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 53 states. [2018-11-23 12:11:23,559 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 53 states to 53 states and 141 transitions. [2018-11-23 12:11:23,559 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 53 states. [2018-11-23 12:11:23,561 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 53 states to 53 states and 141 transitions. [2018-11-23 12:11:23,561 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 53 states and 141 transitions. [2018-11-23 12:11:23,687 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 141 edges. 141 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:23,689 INFO L225 Difference]: With dead ends: 131 [2018-11-23 12:11:23,689 INFO L226 Difference]: Without dead ends: 110 [2018-11-23 12:11:23,691 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 118 GetRequests, 67 SyntacticMatches, 0 SemanticMatches, 51 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 1.1s TimeCoverageRelationStatistics Valid=1378, Invalid=1378, Unknown=0, NotChecked=0, Total=2756 [2018-11-23 12:11:23,691 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 110 states. [2018-11-23 12:11:23,787 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 110 to 80. [2018-11-23 12:11:23,788 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:11:23,788 INFO L82 GeneralOperation]: Start isEquivalent. First operand 110 states. Second operand 80 states. [2018-11-23 12:11:23,788 INFO L74 IsIncluded]: Start isIncluded. First operand 110 states. Second operand 80 states. [2018-11-23 12:11:23,788 INFO L87 Difference]: Start difference. First operand 110 states. Second operand 80 states. [2018-11-23 12:11:23,790 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:23,790 INFO L93 Difference]: Finished difference Result 110 states and 122 transitions. [2018-11-23 12:11:23,790 INFO L276 IsEmpty]: Start isEmpty. Operand 110 states and 122 transitions. [2018-11-23 12:11:23,790 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:23,790 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:23,790 INFO L74 IsIncluded]: Start isIncluded. First operand 80 states. Second operand 110 states. [2018-11-23 12:11:23,790 INFO L87 Difference]: Start difference. First operand 80 states. Second operand 110 states. [2018-11-23 12:11:23,793 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:23,793 INFO L93 Difference]: Finished difference Result 110 states and 122 transitions. [2018-11-23 12:11:23,793 INFO L276 IsEmpty]: Start isEmpty. Operand 110 states and 122 transitions. [2018-11-23 12:11:23,793 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:23,794 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:23,794 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:11:23,794 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:11:23,794 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 80 states. [2018-11-23 12:11:23,795 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 80 states to 80 states and 82 transitions. [2018-11-23 12:11:23,795 INFO L78 Accepts]: Start accepts. Automaton has 80 states and 82 transitions. Word has length 70 [2018-11-23 12:11:23,796 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:11:23,796 INFO L480 AbstractCegarLoop]: Abstraction has 80 states and 82 transitions. [2018-11-23 12:11:23,796 INFO L481 AbstractCegarLoop]: Interpolant automaton has 53 states. [2018-11-23 12:11:23,796 INFO L276 IsEmpty]: Start isEmpty. Operand 80 states and 82 transitions. [2018-11-23 12:11:23,797 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 77 [2018-11-23 12:11:23,797 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:11:23,797 INFO L402 BasicCegarLoop]: trace histogram [51, 10, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:11:23,797 INFO L423 AbstractCegarLoop]: === Iteration 28 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:11:23,797 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:11:23,797 INFO L82 PathProgramCache]: Analyzing trace with hash 862067754, now seen corresponding path program 25 times [2018-11-23 12:11:23,798 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:11:23,798 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:11:23,798 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:23,798 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:11:23,799 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:23,860 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:25,942 INFO L256 TraceCheckUtils]: 0: Hoare triple {11621#true} call ULTIMATE.init(); {11621#true} is VALID [2018-11-23 12:11:25,942 INFO L273 TraceCheckUtils]: 1: Hoare triple {11621#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {11621#true} is VALID [2018-11-23 12:11:25,942 INFO L273 TraceCheckUtils]: 2: Hoare triple {11621#true} assume true; {11621#true} is VALID [2018-11-23 12:11:25,942 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {11621#true} {11621#true} #60#return; {11621#true} is VALID [2018-11-23 12:11:25,943 INFO L256 TraceCheckUtils]: 4: Hoare triple {11621#true} call #t~ret4 := main(); {11621#true} is VALID [2018-11-23 12:11:25,943 INFO L273 TraceCheckUtils]: 5: Hoare triple {11621#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {11623#(= main_~i~0 0)} is VALID [2018-11-23 12:11:25,944 INFO L273 TraceCheckUtils]: 6: Hoare triple {11623#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11624#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:25,945 INFO L273 TraceCheckUtils]: 7: Hoare triple {11624#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11625#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:25,945 INFO L273 TraceCheckUtils]: 8: Hoare triple {11625#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11626#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:25,946 INFO L273 TraceCheckUtils]: 9: Hoare triple {11626#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11627#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:25,946 INFO L273 TraceCheckUtils]: 10: Hoare triple {11627#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11628#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:25,947 INFO L273 TraceCheckUtils]: 11: Hoare triple {11628#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11629#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:25,948 INFO L273 TraceCheckUtils]: 12: Hoare triple {11629#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11630#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:25,949 INFO L273 TraceCheckUtils]: 13: Hoare triple {11630#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11631#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:25,950 INFO L273 TraceCheckUtils]: 14: Hoare triple {11631#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11632#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:25,951 INFO L273 TraceCheckUtils]: 15: Hoare triple {11632#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11633#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:25,952 INFO L273 TraceCheckUtils]: 16: Hoare triple {11633#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11634#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:25,953 INFO L273 TraceCheckUtils]: 17: Hoare triple {11634#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11635#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:25,954 INFO L273 TraceCheckUtils]: 18: Hoare triple {11635#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11636#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:25,954 INFO L273 TraceCheckUtils]: 19: Hoare triple {11636#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11637#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:25,955 INFO L273 TraceCheckUtils]: 20: Hoare triple {11637#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11638#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:25,956 INFO L273 TraceCheckUtils]: 21: Hoare triple {11638#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11639#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:25,957 INFO L273 TraceCheckUtils]: 22: Hoare triple {11639#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11640#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:25,958 INFO L273 TraceCheckUtils]: 23: Hoare triple {11640#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11641#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:25,959 INFO L273 TraceCheckUtils]: 24: Hoare triple {11641#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11642#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:25,960 INFO L273 TraceCheckUtils]: 25: Hoare triple {11642#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11643#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:25,961 INFO L273 TraceCheckUtils]: 26: Hoare triple {11643#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11644#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:25,962 INFO L273 TraceCheckUtils]: 27: Hoare triple {11644#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11645#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:25,963 INFO L273 TraceCheckUtils]: 28: Hoare triple {11645#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11646#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:25,964 INFO L273 TraceCheckUtils]: 29: Hoare triple {11646#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11647#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:25,965 INFO L273 TraceCheckUtils]: 30: Hoare triple {11647#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11648#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:25,966 INFO L273 TraceCheckUtils]: 31: Hoare triple {11648#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11649#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:25,966 INFO L273 TraceCheckUtils]: 32: Hoare triple {11649#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11650#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:25,967 INFO L273 TraceCheckUtils]: 33: Hoare triple {11650#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11651#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:25,968 INFO L273 TraceCheckUtils]: 34: Hoare triple {11651#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11652#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:25,969 INFO L273 TraceCheckUtils]: 35: Hoare triple {11652#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11653#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:25,970 INFO L273 TraceCheckUtils]: 36: Hoare triple {11653#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11654#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:25,971 INFO L273 TraceCheckUtils]: 37: Hoare triple {11654#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11655#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:25,972 INFO L273 TraceCheckUtils]: 38: Hoare triple {11655#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11656#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:25,973 INFO L273 TraceCheckUtils]: 39: Hoare triple {11656#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11657#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:25,974 INFO L273 TraceCheckUtils]: 40: Hoare triple {11657#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11658#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:25,975 INFO L273 TraceCheckUtils]: 41: Hoare triple {11658#(<= main_~i~0 35)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11659#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:25,976 INFO L273 TraceCheckUtils]: 42: Hoare triple {11659#(<= main_~i~0 36)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11660#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:25,977 INFO L273 TraceCheckUtils]: 43: Hoare triple {11660#(<= main_~i~0 37)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11661#(<= main_~i~0 38)} is VALID [2018-11-23 12:11:25,978 INFO L273 TraceCheckUtils]: 44: Hoare triple {11661#(<= main_~i~0 38)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11662#(<= main_~i~0 39)} is VALID [2018-11-23 12:11:25,978 INFO L273 TraceCheckUtils]: 45: Hoare triple {11662#(<= main_~i~0 39)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11663#(<= main_~i~0 40)} is VALID [2018-11-23 12:11:25,979 INFO L273 TraceCheckUtils]: 46: Hoare triple {11663#(<= main_~i~0 40)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11664#(<= main_~i~0 41)} is VALID [2018-11-23 12:11:25,980 INFO L273 TraceCheckUtils]: 47: Hoare triple {11664#(<= main_~i~0 41)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11665#(<= main_~i~0 42)} is VALID [2018-11-23 12:11:25,981 INFO L273 TraceCheckUtils]: 48: Hoare triple {11665#(<= main_~i~0 42)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11666#(<= main_~i~0 43)} is VALID [2018-11-23 12:11:25,982 INFO L273 TraceCheckUtils]: 49: Hoare triple {11666#(<= main_~i~0 43)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11667#(<= main_~i~0 44)} is VALID [2018-11-23 12:11:25,983 INFO L273 TraceCheckUtils]: 50: Hoare triple {11667#(<= main_~i~0 44)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11668#(<= main_~i~0 45)} is VALID [2018-11-23 12:11:25,984 INFO L273 TraceCheckUtils]: 51: Hoare triple {11668#(<= main_~i~0 45)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11669#(<= main_~i~0 46)} is VALID [2018-11-23 12:11:25,985 INFO L273 TraceCheckUtils]: 52: Hoare triple {11669#(<= main_~i~0 46)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11670#(<= main_~i~0 47)} is VALID [2018-11-23 12:11:25,986 INFO L273 TraceCheckUtils]: 53: Hoare triple {11670#(<= main_~i~0 47)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11671#(<= main_~i~0 48)} is VALID [2018-11-23 12:11:25,987 INFO L273 TraceCheckUtils]: 54: Hoare triple {11671#(<= main_~i~0 48)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11672#(<= main_~i~0 49)} is VALID [2018-11-23 12:11:25,988 INFO L273 TraceCheckUtils]: 55: Hoare triple {11672#(<= main_~i~0 49)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11673#(<= main_~i~0 50)} is VALID [2018-11-23 12:11:25,989 INFO L273 TraceCheckUtils]: 56: Hoare triple {11673#(<= main_~i~0 50)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11674#(<= main_~i~0 51)} is VALID [2018-11-23 12:11:25,989 INFO L273 TraceCheckUtils]: 57: Hoare triple {11674#(<= main_~i~0 51)} assume !(~i~0 < 100000); {11622#false} is VALID [2018-11-23 12:11:25,990 INFO L273 TraceCheckUtils]: 58: Hoare triple {11622#false} ~i~0 := 1; {11622#false} is VALID [2018-11-23 12:11:25,990 INFO L273 TraceCheckUtils]: 59: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:25,990 INFO L273 TraceCheckUtils]: 60: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:25,990 INFO L273 TraceCheckUtils]: 61: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:25,990 INFO L273 TraceCheckUtils]: 62: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:25,991 INFO L273 TraceCheckUtils]: 63: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:25,991 INFO L273 TraceCheckUtils]: 64: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:25,991 INFO L273 TraceCheckUtils]: 65: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:25,991 INFO L273 TraceCheckUtils]: 66: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:25,991 INFO L273 TraceCheckUtils]: 67: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:25,992 INFO L273 TraceCheckUtils]: 68: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:25,992 INFO L273 TraceCheckUtils]: 69: Hoare triple {11622#false} assume !(~i~0 < 100000); {11622#false} is VALID [2018-11-23 12:11:25,992 INFO L273 TraceCheckUtils]: 70: Hoare triple {11622#false} ~i~0 := 1;~j~0 := 0; {11622#false} is VALID [2018-11-23 12:11:25,992 INFO L273 TraceCheckUtils]: 71: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {11622#false} is VALID [2018-11-23 12:11:25,992 INFO L256 TraceCheckUtils]: 72: Hoare triple {11622#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {11622#false} is VALID [2018-11-23 12:11:25,992 INFO L273 TraceCheckUtils]: 73: Hoare triple {11622#false} ~cond := #in~cond; {11622#false} is VALID [2018-11-23 12:11:25,993 INFO L273 TraceCheckUtils]: 74: Hoare triple {11622#false} assume 0 == ~cond; {11622#false} is VALID [2018-11-23 12:11:25,993 INFO L273 TraceCheckUtils]: 75: Hoare triple {11622#false} assume !false; {11622#false} is VALID [2018-11-23 12:11:25,997 INFO L134 CoverageAnalysis]: Checked inductivity of 1381 backedges. 0 proven. 1326 refuted. 0 times theorem prover too weak. 55 trivial. 0 not checked. [2018-11-23 12:11:25,997 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:11:25,997 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 26 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 26 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:11:26,006 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:11:26,072 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:26,095 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:26,097 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:11:26,397 INFO L256 TraceCheckUtils]: 0: Hoare triple {11621#true} call ULTIMATE.init(); {11621#true} is VALID [2018-11-23 12:11:26,397 INFO L273 TraceCheckUtils]: 1: Hoare triple {11621#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {11621#true} is VALID [2018-11-23 12:11:26,397 INFO L273 TraceCheckUtils]: 2: Hoare triple {11621#true} assume true; {11621#true} is VALID [2018-11-23 12:11:26,397 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {11621#true} {11621#true} #60#return; {11621#true} is VALID [2018-11-23 12:11:26,397 INFO L256 TraceCheckUtils]: 4: Hoare triple {11621#true} call #t~ret4 := main(); {11621#true} is VALID [2018-11-23 12:11:26,398 INFO L273 TraceCheckUtils]: 5: Hoare triple {11621#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {11693#(<= main_~i~0 0)} is VALID [2018-11-23 12:11:26,398 INFO L273 TraceCheckUtils]: 6: Hoare triple {11693#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11624#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:26,399 INFO L273 TraceCheckUtils]: 7: Hoare triple {11624#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11625#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:26,400 INFO L273 TraceCheckUtils]: 8: Hoare triple {11625#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11626#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:26,400 INFO L273 TraceCheckUtils]: 9: Hoare triple {11626#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11627#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:26,401 INFO L273 TraceCheckUtils]: 10: Hoare triple {11627#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11628#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:26,402 INFO L273 TraceCheckUtils]: 11: Hoare triple {11628#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11629#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:26,403 INFO L273 TraceCheckUtils]: 12: Hoare triple {11629#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11630#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:26,404 INFO L273 TraceCheckUtils]: 13: Hoare triple {11630#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11631#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:26,405 INFO L273 TraceCheckUtils]: 14: Hoare triple {11631#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11632#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:26,405 INFO L273 TraceCheckUtils]: 15: Hoare triple {11632#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11633#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:26,406 INFO L273 TraceCheckUtils]: 16: Hoare triple {11633#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11634#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:26,407 INFO L273 TraceCheckUtils]: 17: Hoare triple {11634#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11635#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:26,408 INFO L273 TraceCheckUtils]: 18: Hoare triple {11635#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11636#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:26,409 INFO L273 TraceCheckUtils]: 19: Hoare triple {11636#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11637#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:26,410 INFO L273 TraceCheckUtils]: 20: Hoare triple {11637#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11638#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:26,411 INFO L273 TraceCheckUtils]: 21: Hoare triple {11638#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11639#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:26,412 INFO L273 TraceCheckUtils]: 22: Hoare triple {11639#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11640#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:26,413 INFO L273 TraceCheckUtils]: 23: Hoare triple {11640#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11641#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:26,414 INFO L273 TraceCheckUtils]: 24: Hoare triple {11641#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11642#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:26,415 INFO L273 TraceCheckUtils]: 25: Hoare triple {11642#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11643#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:26,416 INFO L273 TraceCheckUtils]: 26: Hoare triple {11643#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11644#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:26,417 INFO L273 TraceCheckUtils]: 27: Hoare triple {11644#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11645#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:26,418 INFO L273 TraceCheckUtils]: 28: Hoare triple {11645#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11646#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:26,418 INFO L273 TraceCheckUtils]: 29: Hoare triple {11646#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11647#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:26,419 INFO L273 TraceCheckUtils]: 30: Hoare triple {11647#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11648#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:26,420 INFO L273 TraceCheckUtils]: 31: Hoare triple {11648#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11649#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:26,421 INFO L273 TraceCheckUtils]: 32: Hoare triple {11649#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11650#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:26,422 INFO L273 TraceCheckUtils]: 33: Hoare triple {11650#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11651#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:26,423 INFO L273 TraceCheckUtils]: 34: Hoare triple {11651#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11652#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:26,424 INFO L273 TraceCheckUtils]: 35: Hoare triple {11652#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11653#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:26,425 INFO L273 TraceCheckUtils]: 36: Hoare triple {11653#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11654#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:26,426 INFO L273 TraceCheckUtils]: 37: Hoare triple {11654#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11655#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:26,427 INFO L273 TraceCheckUtils]: 38: Hoare triple {11655#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11656#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:26,428 INFO L273 TraceCheckUtils]: 39: Hoare triple {11656#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11657#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:26,429 INFO L273 TraceCheckUtils]: 40: Hoare triple {11657#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11658#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:26,430 INFO L273 TraceCheckUtils]: 41: Hoare triple {11658#(<= main_~i~0 35)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11659#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:26,430 INFO L273 TraceCheckUtils]: 42: Hoare triple {11659#(<= main_~i~0 36)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11660#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:26,431 INFO L273 TraceCheckUtils]: 43: Hoare triple {11660#(<= main_~i~0 37)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11661#(<= main_~i~0 38)} is VALID [2018-11-23 12:11:26,432 INFO L273 TraceCheckUtils]: 44: Hoare triple {11661#(<= main_~i~0 38)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11662#(<= main_~i~0 39)} is VALID [2018-11-23 12:11:26,433 INFO L273 TraceCheckUtils]: 45: Hoare triple {11662#(<= main_~i~0 39)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11663#(<= main_~i~0 40)} is VALID [2018-11-23 12:11:26,434 INFO L273 TraceCheckUtils]: 46: Hoare triple {11663#(<= main_~i~0 40)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11664#(<= main_~i~0 41)} is VALID [2018-11-23 12:11:26,435 INFO L273 TraceCheckUtils]: 47: Hoare triple {11664#(<= main_~i~0 41)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11665#(<= main_~i~0 42)} is VALID [2018-11-23 12:11:26,436 INFO L273 TraceCheckUtils]: 48: Hoare triple {11665#(<= main_~i~0 42)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11666#(<= main_~i~0 43)} is VALID [2018-11-23 12:11:26,437 INFO L273 TraceCheckUtils]: 49: Hoare triple {11666#(<= main_~i~0 43)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11667#(<= main_~i~0 44)} is VALID [2018-11-23 12:11:26,438 INFO L273 TraceCheckUtils]: 50: Hoare triple {11667#(<= main_~i~0 44)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11668#(<= main_~i~0 45)} is VALID [2018-11-23 12:11:26,439 INFO L273 TraceCheckUtils]: 51: Hoare triple {11668#(<= main_~i~0 45)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11669#(<= main_~i~0 46)} is VALID [2018-11-23 12:11:26,440 INFO L273 TraceCheckUtils]: 52: Hoare triple {11669#(<= main_~i~0 46)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11670#(<= main_~i~0 47)} is VALID [2018-11-23 12:11:26,441 INFO L273 TraceCheckUtils]: 53: Hoare triple {11670#(<= main_~i~0 47)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11671#(<= main_~i~0 48)} is VALID [2018-11-23 12:11:26,442 INFO L273 TraceCheckUtils]: 54: Hoare triple {11671#(<= main_~i~0 48)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11672#(<= main_~i~0 49)} is VALID [2018-11-23 12:11:26,442 INFO L273 TraceCheckUtils]: 55: Hoare triple {11672#(<= main_~i~0 49)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11673#(<= main_~i~0 50)} is VALID [2018-11-23 12:11:26,443 INFO L273 TraceCheckUtils]: 56: Hoare triple {11673#(<= main_~i~0 50)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {11674#(<= main_~i~0 51)} is VALID [2018-11-23 12:11:26,444 INFO L273 TraceCheckUtils]: 57: Hoare triple {11674#(<= main_~i~0 51)} assume !(~i~0 < 100000); {11622#false} is VALID [2018-11-23 12:11:26,444 INFO L273 TraceCheckUtils]: 58: Hoare triple {11622#false} ~i~0 := 1; {11622#false} is VALID [2018-11-23 12:11:26,444 INFO L273 TraceCheckUtils]: 59: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:26,445 INFO L273 TraceCheckUtils]: 60: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:26,445 INFO L273 TraceCheckUtils]: 61: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:26,445 INFO L273 TraceCheckUtils]: 62: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:26,445 INFO L273 TraceCheckUtils]: 63: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:26,445 INFO L273 TraceCheckUtils]: 64: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:26,446 INFO L273 TraceCheckUtils]: 65: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:26,446 INFO L273 TraceCheckUtils]: 66: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:26,446 INFO L273 TraceCheckUtils]: 67: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:26,446 INFO L273 TraceCheckUtils]: 68: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {11622#false} is VALID [2018-11-23 12:11:26,446 INFO L273 TraceCheckUtils]: 69: Hoare triple {11622#false} assume !(~i~0 < 100000); {11622#false} is VALID [2018-11-23 12:11:26,446 INFO L273 TraceCheckUtils]: 70: Hoare triple {11622#false} ~i~0 := 1;~j~0 := 0; {11622#false} is VALID [2018-11-23 12:11:26,447 INFO L273 TraceCheckUtils]: 71: Hoare triple {11622#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {11622#false} is VALID [2018-11-23 12:11:26,447 INFO L256 TraceCheckUtils]: 72: Hoare triple {11622#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {11622#false} is VALID [2018-11-23 12:11:26,447 INFO L273 TraceCheckUtils]: 73: Hoare triple {11622#false} ~cond := #in~cond; {11622#false} is VALID [2018-11-23 12:11:26,447 INFO L273 TraceCheckUtils]: 74: Hoare triple {11622#false} assume 0 == ~cond; {11622#false} is VALID [2018-11-23 12:11:26,447 INFO L273 TraceCheckUtils]: 75: Hoare triple {11622#false} assume !false; {11622#false} is VALID [2018-11-23 12:11:26,451 INFO L134 CoverageAnalysis]: Checked inductivity of 1381 backedges. 0 proven. 1326 refuted. 0 times theorem prover too weak. 55 trivial. 0 not checked. [2018-11-23 12:11:26,471 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:11:26,471 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [54, 54] total 55 [2018-11-23 12:11:26,471 INFO L78 Accepts]: Start accepts. Automaton has 55 states. Word has length 76 [2018-11-23 12:11:26,472 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:11:26,472 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 55 states. [2018-11-23 12:11:26,520 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 69 edges. 69 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:26,520 INFO L459 AbstractCegarLoop]: Interpolant automaton has 55 states [2018-11-23 12:11:26,521 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 55 interpolants. [2018-11-23 12:11:26,522 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1485, Invalid=1485, Unknown=0, NotChecked=0, Total=2970 [2018-11-23 12:11:26,523 INFO L87 Difference]: Start difference. First operand 80 states and 82 transitions. Second operand 55 states. [2018-11-23 12:11:27,675 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:27,675 INFO L93 Difference]: Finished difference Result 121 states and 131 transitions. [2018-11-23 12:11:27,675 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 54 states. [2018-11-23 12:11:27,675 INFO L78 Accepts]: Start accepts. Automaton has 55 states. Word has length 76 [2018-11-23 12:11:27,676 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:11:27,676 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 55 states. [2018-11-23 12:11:27,677 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 54 states to 54 states and 117 transitions. [2018-11-23 12:11:27,677 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 55 states. [2018-11-23 12:11:27,679 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 54 states to 54 states and 117 transitions. [2018-11-23 12:11:27,679 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 54 states and 117 transitions. [2018-11-23 12:11:27,794 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 117 edges. 117 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:27,796 INFO L225 Difference]: With dead ends: 121 [2018-11-23 12:11:27,796 INFO L226 Difference]: Without dead ends: 99 [2018-11-23 12:11:27,797 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 129 GetRequests, 76 SyntacticMatches, 0 SemanticMatches, 53 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 100 ImplicationChecksByTransitivity, 1.7s TimeCoverageRelationStatistics Valid=1485, Invalid=1485, Unknown=0, NotChecked=0, Total=2970 [2018-11-23 12:11:27,797 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 99 states. [2018-11-23 12:11:27,868 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 99 to 81. [2018-11-23 12:11:27,868 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:11:27,868 INFO L82 GeneralOperation]: Start isEquivalent. First operand 99 states. Second operand 81 states. [2018-11-23 12:11:27,868 INFO L74 IsIncluded]: Start isIncluded. First operand 99 states. Second operand 81 states. [2018-11-23 12:11:27,868 INFO L87 Difference]: Start difference. First operand 99 states. Second operand 81 states. [2018-11-23 12:11:27,870 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:27,871 INFO L93 Difference]: Finished difference Result 99 states and 107 transitions. [2018-11-23 12:11:27,871 INFO L276 IsEmpty]: Start isEmpty. Operand 99 states and 107 transitions. [2018-11-23 12:11:27,871 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:27,871 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:27,871 INFO L74 IsIncluded]: Start isIncluded. First operand 81 states. Second operand 99 states. [2018-11-23 12:11:27,872 INFO L87 Difference]: Start difference. First operand 81 states. Second operand 99 states. [2018-11-23 12:11:27,873 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:27,874 INFO L93 Difference]: Finished difference Result 99 states and 107 transitions. [2018-11-23 12:11:27,874 INFO L276 IsEmpty]: Start isEmpty. Operand 99 states and 107 transitions. [2018-11-23 12:11:27,874 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:27,874 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:27,875 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:11:27,875 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:11:27,875 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 81 states. [2018-11-23 12:11:27,876 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 81 states to 81 states and 83 transitions. [2018-11-23 12:11:27,876 INFO L78 Accepts]: Start accepts. Automaton has 81 states and 83 transitions. Word has length 76 [2018-11-23 12:11:27,876 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:11:27,876 INFO L480 AbstractCegarLoop]: Abstraction has 81 states and 83 transitions. [2018-11-23 12:11:27,876 INFO L481 AbstractCegarLoop]: Interpolant automaton has 55 states. [2018-11-23 12:11:27,877 INFO L276 IsEmpty]: Start isEmpty. Operand 81 states and 83 transitions. [2018-11-23 12:11:27,877 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 78 [2018-11-23 12:11:27,877 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:11:27,877 INFO L402 BasicCegarLoop]: trace histogram [52, 10, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:11:27,878 INFO L423 AbstractCegarLoop]: === Iteration 29 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:11:27,878 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:11:27,878 INFO L82 PathProgramCache]: Analyzing trace with hash -825632122, now seen corresponding path program 26 times [2018-11-23 12:11:27,878 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:11:27,878 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:11:27,879 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:27,879 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:11:27,879 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:27,940 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:29,861 INFO L256 TraceCheckUtils]: 0: Hoare triple {12471#true} call ULTIMATE.init(); {12471#true} is VALID [2018-11-23 12:11:29,861 INFO L273 TraceCheckUtils]: 1: Hoare triple {12471#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {12471#true} is VALID [2018-11-23 12:11:29,862 INFO L273 TraceCheckUtils]: 2: Hoare triple {12471#true} assume true; {12471#true} is VALID [2018-11-23 12:11:29,862 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {12471#true} {12471#true} #60#return; {12471#true} is VALID [2018-11-23 12:11:29,862 INFO L256 TraceCheckUtils]: 4: Hoare triple {12471#true} call #t~ret4 := main(); {12471#true} is VALID [2018-11-23 12:11:29,862 INFO L273 TraceCheckUtils]: 5: Hoare triple {12471#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {12473#(= main_~i~0 0)} is VALID [2018-11-23 12:11:29,863 INFO L273 TraceCheckUtils]: 6: Hoare triple {12473#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12474#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:29,864 INFO L273 TraceCheckUtils]: 7: Hoare triple {12474#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12475#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:29,865 INFO L273 TraceCheckUtils]: 8: Hoare triple {12475#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12476#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:29,866 INFO L273 TraceCheckUtils]: 9: Hoare triple {12476#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12477#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:29,867 INFO L273 TraceCheckUtils]: 10: Hoare triple {12477#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12478#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:29,868 INFO L273 TraceCheckUtils]: 11: Hoare triple {12478#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12479#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:29,869 INFO L273 TraceCheckUtils]: 12: Hoare triple {12479#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12480#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:29,870 INFO L273 TraceCheckUtils]: 13: Hoare triple {12480#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12481#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:29,871 INFO L273 TraceCheckUtils]: 14: Hoare triple {12481#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12482#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:29,872 INFO L273 TraceCheckUtils]: 15: Hoare triple {12482#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12483#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:29,873 INFO L273 TraceCheckUtils]: 16: Hoare triple {12483#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12484#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:29,873 INFO L273 TraceCheckUtils]: 17: Hoare triple {12484#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12485#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:29,874 INFO L273 TraceCheckUtils]: 18: Hoare triple {12485#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12486#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:29,875 INFO L273 TraceCheckUtils]: 19: Hoare triple {12486#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12487#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:29,876 INFO L273 TraceCheckUtils]: 20: Hoare triple {12487#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12488#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:29,877 INFO L273 TraceCheckUtils]: 21: Hoare triple {12488#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12489#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:29,878 INFO L273 TraceCheckUtils]: 22: Hoare triple {12489#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12490#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:29,879 INFO L273 TraceCheckUtils]: 23: Hoare triple {12490#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12491#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:29,880 INFO L273 TraceCheckUtils]: 24: Hoare triple {12491#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12492#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:29,881 INFO L273 TraceCheckUtils]: 25: Hoare triple {12492#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12493#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:29,882 INFO L273 TraceCheckUtils]: 26: Hoare triple {12493#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12494#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:29,883 INFO L273 TraceCheckUtils]: 27: Hoare triple {12494#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12495#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:29,884 INFO L273 TraceCheckUtils]: 28: Hoare triple {12495#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12496#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:29,885 INFO L273 TraceCheckUtils]: 29: Hoare triple {12496#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12497#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:29,885 INFO L273 TraceCheckUtils]: 30: Hoare triple {12497#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12498#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:29,886 INFO L273 TraceCheckUtils]: 31: Hoare triple {12498#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12499#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:29,887 INFO L273 TraceCheckUtils]: 32: Hoare triple {12499#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12500#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:29,888 INFO L273 TraceCheckUtils]: 33: Hoare triple {12500#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12501#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:29,889 INFO L273 TraceCheckUtils]: 34: Hoare triple {12501#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12502#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:29,890 INFO L273 TraceCheckUtils]: 35: Hoare triple {12502#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12503#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:29,891 INFO L273 TraceCheckUtils]: 36: Hoare triple {12503#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12504#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:29,892 INFO L273 TraceCheckUtils]: 37: Hoare triple {12504#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12505#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:29,893 INFO L273 TraceCheckUtils]: 38: Hoare triple {12505#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12506#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:29,894 INFO L273 TraceCheckUtils]: 39: Hoare triple {12506#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12507#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:29,895 INFO L273 TraceCheckUtils]: 40: Hoare triple {12507#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12508#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:29,896 INFO L273 TraceCheckUtils]: 41: Hoare triple {12508#(<= main_~i~0 35)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12509#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:29,897 INFO L273 TraceCheckUtils]: 42: Hoare triple {12509#(<= main_~i~0 36)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12510#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:29,898 INFO L273 TraceCheckUtils]: 43: Hoare triple {12510#(<= main_~i~0 37)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12511#(<= main_~i~0 38)} is VALID [2018-11-23 12:11:29,899 INFO L273 TraceCheckUtils]: 44: Hoare triple {12511#(<= main_~i~0 38)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12512#(<= main_~i~0 39)} is VALID [2018-11-23 12:11:29,900 INFO L273 TraceCheckUtils]: 45: Hoare triple {12512#(<= main_~i~0 39)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12513#(<= main_~i~0 40)} is VALID [2018-11-23 12:11:29,901 INFO L273 TraceCheckUtils]: 46: Hoare triple {12513#(<= main_~i~0 40)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12514#(<= main_~i~0 41)} is VALID [2018-11-23 12:11:29,902 INFO L273 TraceCheckUtils]: 47: Hoare triple {12514#(<= main_~i~0 41)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12515#(<= main_~i~0 42)} is VALID [2018-11-23 12:11:29,903 INFO L273 TraceCheckUtils]: 48: Hoare triple {12515#(<= main_~i~0 42)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12516#(<= main_~i~0 43)} is VALID [2018-11-23 12:11:29,904 INFO L273 TraceCheckUtils]: 49: Hoare triple {12516#(<= main_~i~0 43)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12517#(<= main_~i~0 44)} is VALID [2018-11-23 12:11:29,905 INFO L273 TraceCheckUtils]: 50: Hoare triple {12517#(<= main_~i~0 44)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12518#(<= main_~i~0 45)} is VALID [2018-11-23 12:11:29,906 INFO L273 TraceCheckUtils]: 51: Hoare triple {12518#(<= main_~i~0 45)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12519#(<= main_~i~0 46)} is VALID [2018-11-23 12:11:29,907 INFO L273 TraceCheckUtils]: 52: Hoare triple {12519#(<= main_~i~0 46)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12520#(<= main_~i~0 47)} is VALID [2018-11-23 12:11:29,908 INFO L273 TraceCheckUtils]: 53: Hoare triple {12520#(<= main_~i~0 47)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12521#(<= main_~i~0 48)} is VALID [2018-11-23 12:11:29,909 INFO L273 TraceCheckUtils]: 54: Hoare triple {12521#(<= main_~i~0 48)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12522#(<= main_~i~0 49)} is VALID [2018-11-23 12:11:29,910 INFO L273 TraceCheckUtils]: 55: Hoare triple {12522#(<= main_~i~0 49)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12523#(<= main_~i~0 50)} is VALID [2018-11-23 12:11:29,911 INFO L273 TraceCheckUtils]: 56: Hoare triple {12523#(<= main_~i~0 50)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12524#(<= main_~i~0 51)} is VALID [2018-11-23 12:11:29,912 INFO L273 TraceCheckUtils]: 57: Hoare triple {12524#(<= main_~i~0 51)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12525#(<= main_~i~0 52)} is VALID [2018-11-23 12:11:29,913 INFO L273 TraceCheckUtils]: 58: Hoare triple {12525#(<= main_~i~0 52)} assume !(~i~0 < 100000); {12472#false} is VALID [2018-11-23 12:11:29,913 INFO L273 TraceCheckUtils]: 59: Hoare triple {12472#false} ~i~0 := 1; {12472#false} is VALID [2018-11-23 12:11:29,913 INFO L273 TraceCheckUtils]: 60: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:29,913 INFO L273 TraceCheckUtils]: 61: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:29,913 INFO L273 TraceCheckUtils]: 62: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:29,914 INFO L273 TraceCheckUtils]: 63: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:29,914 INFO L273 TraceCheckUtils]: 64: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:29,914 INFO L273 TraceCheckUtils]: 65: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:29,914 INFO L273 TraceCheckUtils]: 66: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:29,914 INFO L273 TraceCheckUtils]: 67: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:29,915 INFO L273 TraceCheckUtils]: 68: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:29,915 INFO L273 TraceCheckUtils]: 69: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:29,915 INFO L273 TraceCheckUtils]: 70: Hoare triple {12472#false} assume !(~i~0 < 100000); {12472#false} is VALID [2018-11-23 12:11:29,915 INFO L273 TraceCheckUtils]: 71: Hoare triple {12472#false} ~i~0 := 1;~j~0 := 0; {12472#false} is VALID [2018-11-23 12:11:29,915 INFO L273 TraceCheckUtils]: 72: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {12472#false} is VALID [2018-11-23 12:11:29,915 INFO L256 TraceCheckUtils]: 73: Hoare triple {12472#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {12472#false} is VALID [2018-11-23 12:11:29,916 INFO L273 TraceCheckUtils]: 74: Hoare triple {12472#false} ~cond := #in~cond; {12472#false} is VALID [2018-11-23 12:11:29,916 INFO L273 TraceCheckUtils]: 75: Hoare triple {12472#false} assume 0 == ~cond; {12472#false} is VALID [2018-11-23 12:11:29,916 INFO L273 TraceCheckUtils]: 76: Hoare triple {12472#false} assume !false; {12472#false} is VALID [2018-11-23 12:11:29,920 INFO L134 CoverageAnalysis]: Checked inductivity of 1433 backedges. 0 proven. 1378 refuted. 0 times theorem prover too weak. 55 trivial. 0 not checked. [2018-11-23 12:11:29,920 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:11:29,920 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 27 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 27 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:11:29,929 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:11:29,994 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:11:29,995 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:11:30,018 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:30,019 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:11:30,339 INFO L256 TraceCheckUtils]: 0: Hoare triple {12471#true} call ULTIMATE.init(); {12471#true} is VALID [2018-11-23 12:11:30,339 INFO L273 TraceCheckUtils]: 1: Hoare triple {12471#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {12471#true} is VALID [2018-11-23 12:11:30,339 INFO L273 TraceCheckUtils]: 2: Hoare triple {12471#true} assume true; {12471#true} is VALID [2018-11-23 12:11:30,339 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {12471#true} {12471#true} #60#return; {12471#true} is VALID [2018-11-23 12:11:30,339 INFO L256 TraceCheckUtils]: 4: Hoare triple {12471#true} call #t~ret4 := main(); {12471#true} is VALID [2018-11-23 12:11:30,341 INFO L273 TraceCheckUtils]: 5: Hoare triple {12471#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {12544#(<= main_~i~0 0)} is VALID [2018-11-23 12:11:30,341 INFO L273 TraceCheckUtils]: 6: Hoare triple {12544#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12474#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:30,343 INFO L273 TraceCheckUtils]: 7: Hoare triple {12474#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12475#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:30,344 INFO L273 TraceCheckUtils]: 8: Hoare triple {12475#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12476#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:30,345 INFO L273 TraceCheckUtils]: 9: Hoare triple {12476#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12477#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:30,346 INFO L273 TraceCheckUtils]: 10: Hoare triple {12477#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12478#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:30,347 INFO L273 TraceCheckUtils]: 11: Hoare triple {12478#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12479#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:30,348 INFO L273 TraceCheckUtils]: 12: Hoare triple {12479#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12480#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:30,349 INFO L273 TraceCheckUtils]: 13: Hoare triple {12480#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12481#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:30,350 INFO L273 TraceCheckUtils]: 14: Hoare triple {12481#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12482#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:30,351 INFO L273 TraceCheckUtils]: 15: Hoare triple {12482#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12483#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:30,352 INFO L273 TraceCheckUtils]: 16: Hoare triple {12483#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12484#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:30,353 INFO L273 TraceCheckUtils]: 17: Hoare triple {12484#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12485#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:30,354 INFO L273 TraceCheckUtils]: 18: Hoare triple {12485#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12486#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:30,355 INFO L273 TraceCheckUtils]: 19: Hoare triple {12486#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12487#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:30,356 INFO L273 TraceCheckUtils]: 20: Hoare triple {12487#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12488#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:30,357 INFO L273 TraceCheckUtils]: 21: Hoare triple {12488#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12489#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:30,358 INFO L273 TraceCheckUtils]: 22: Hoare triple {12489#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12490#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:30,359 INFO L273 TraceCheckUtils]: 23: Hoare triple {12490#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12491#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:30,360 INFO L273 TraceCheckUtils]: 24: Hoare triple {12491#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12492#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:30,363 INFO L273 TraceCheckUtils]: 25: Hoare triple {12492#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12493#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:30,363 INFO L273 TraceCheckUtils]: 26: Hoare triple {12493#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12494#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:30,365 INFO L273 TraceCheckUtils]: 27: Hoare triple {12494#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12495#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:30,365 INFO L273 TraceCheckUtils]: 28: Hoare triple {12495#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12496#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:30,367 INFO L273 TraceCheckUtils]: 29: Hoare triple {12496#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12497#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:30,369 INFO L273 TraceCheckUtils]: 30: Hoare triple {12497#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12498#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:30,370 INFO L273 TraceCheckUtils]: 31: Hoare triple {12498#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12499#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:30,371 INFO L273 TraceCheckUtils]: 32: Hoare triple {12499#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12500#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:30,371 INFO L273 TraceCheckUtils]: 33: Hoare triple {12500#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12501#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:30,373 INFO L273 TraceCheckUtils]: 34: Hoare triple {12501#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12502#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:30,374 INFO L273 TraceCheckUtils]: 35: Hoare triple {12502#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12503#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:30,375 INFO L273 TraceCheckUtils]: 36: Hoare triple {12503#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12504#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:30,376 INFO L273 TraceCheckUtils]: 37: Hoare triple {12504#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12505#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:30,377 INFO L273 TraceCheckUtils]: 38: Hoare triple {12505#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12506#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:30,378 INFO L273 TraceCheckUtils]: 39: Hoare triple {12506#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12507#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:30,379 INFO L273 TraceCheckUtils]: 40: Hoare triple {12507#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12508#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:30,380 INFO L273 TraceCheckUtils]: 41: Hoare triple {12508#(<= main_~i~0 35)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12509#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:30,381 INFO L273 TraceCheckUtils]: 42: Hoare triple {12509#(<= main_~i~0 36)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12510#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:30,382 INFO L273 TraceCheckUtils]: 43: Hoare triple {12510#(<= main_~i~0 37)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12511#(<= main_~i~0 38)} is VALID [2018-11-23 12:11:30,383 INFO L273 TraceCheckUtils]: 44: Hoare triple {12511#(<= main_~i~0 38)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12512#(<= main_~i~0 39)} is VALID [2018-11-23 12:11:30,384 INFO L273 TraceCheckUtils]: 45: Hoare triple {12512#(<= main_~i~0 39)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12513#(<= main_~i~0 40)} is VALID [2018-11-23 12:11:30,385 INFO L273 TraceCheckUtils]: 46: Hoare triple {12513#(<= main_~i~0 40)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12514#(<= main_~i~0 41)} is VALID [2018-11-23 12:11:30,386 INFO L273 TraceCheckUtils]: 47: Hoare triple {12514#(<= main_~i~0 41)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12515#(<= main_~i~0 42)} is VALID [2018-11-23 12:11:30,387 INFO L273 TraceCheckUtils]: 48: Hoare triple {12515#(<= main_~i~0 42)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12516#(<= main_~i~0 43)} is VALID [2018-11-23 12:11:30,388 INFO L273 TraceCheckUtils]: 49: Hoare triple {12516#(<= main_~i~0 43)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12517#(<= main_~i~0 44)} is VALID [2018-11-23 12:11:30,389 INFO L273 TraceCheckUtils]: 50: Hoare triple {12517#(<= main_~i~0 44)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12518#(<= main_~i~0 45)} is VALID [2018-11-23 12:11:30,393 INFO L273 TraceCheckUtils]: 51: Hoare triple {12518#(<= main_~i~0 45)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12519#(<= main_~i~0 46)} is VALID [2018-11-23 12:11:30,393 INFO L273 TraceCheckUtils]: 52: Hoare triple {12519#(<= main_~i~0 46)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12520#(<= main_~i~0 47)} is VALID [2018-11-23 12:11:30,395 INFO L273 TraceCheckUtils]: 53: Hoare triple {12520#(<= main_~i~0 47)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12521#(<= main_~i~0 48)} is VALID [2018-11-23 12:11:30,395 INFO L273 TraceCheckUtils]: 54: Hoare triple {12521#(<= main_~i~0 48)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12522#(<= main_~i~0 49)} is VALID [2018-11-23 12:11:30,397 INFO L273 TraceCheckUtils]: 55: Hoare triple {12522#(<= main_~i~0 49)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12523#(<= main_~i~0 50)} is VALID [2018-11-23 12:11:30,398 INFO L273 TraceCheckUtils]: 56: Hoare triple {12523#(<= main_~i~0 50)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12524#(<= main_~i~0 51)} is VALID [2018-11-23 12:11:30,399 INFO L273 TraceCheckUtils]: 57: Hoare triple {12524#(<= main_~i~0 51)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {12525#(<= main_~i~0 52)} is VALID [2018-11-23 12:11:30,399 INFO L273 TraceCheckUtils]: 58: Hoare triple {12525#(<= main_~i~0 52)} assume !(~i~0 < 100000); {12472#false} is VALID [2018-11-23 12:11:30,400 INFO L273 TraceCheckUtils]: 59: Hoare triple {12472#false} ~i~0 := 1; {12472#false} is VALID [2018-11-23 12:11:30,400 INFO L273 TraceCheckUtils]: 60: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:30,400 INFO L273 TraceCheckUtils]: 61: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:30,400 INFO L273 TraceCheckUtils]: 62: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:30,400 INFO L273 TraceCheckUtils]: 63: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:30,401 INFO L273 TraceCheckUtils]: 64: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:30,401 INFO L273 TraceCheckUtils]: 65: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:30,401 INFO L273 TraceCheckUtils]: 66: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:30,401 INFO L273 TraceCheckUtils]: 67: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:30,401 INFO L273 TraceCheckUtils]: 68: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:30,402 INFO L273 TraceCheckUtils]: 69: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {12472#false} is VALID [2018-11-23 12:11:30,402 INFO L273 TraceCheckUtils]: 70: Hoare triple {12472#false} assume !(~i~0 < 100000); {12472#false} is VALID [2018-11-23 12:11:30,402 INFO L273 TraceCheckUtils]: 71: Hoare triple {12472#false} ~i~0 := 1;~j~0 := 0; {12472#false} is VALID [2018-11-23 12:11:30,402 INFO L273 TraceCheckUtils]: 72: Hoare triple {12472#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {12472#false} is VALID [2018-11-23 12:11:30,402 INFO L256 TraceCheckUtils]: 73: Hoare triple {12472#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {12472#false} is VALID [2018-11-23 12:11:30,402 INFO L273 TraceCheckUtils]: 74: Hoare triple {12472#false} ~cond := #in~cond; {12472#false} is VALID [2018-11-23 12:11:30,402 INFO L273 TraceCheckUtils]: 75: Hoare triple {12472#false} assume 0 == ~cond; {12472#false} is VALID [2018-11-23 12:11:30,403 INFO L273 TraceCheckUtils]: 76: Hoare triple {12472#false} assume !false; {12472#false} is VALID [2018-11-23 12:11:30,407 INFO L134 CoverageAnalysis]: Checked inductivity of 1433 backedges. 0 proven. 1378 refuted. 0 times theorem prover too weak. 55 trivial. 0 not checked. [2018-11-23 12:11:30,426 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:11:30,426 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [55, 55] total 56 [2018-11-23 12:11:30,426 INFO L78 Accepts]: Start accepts. Automaton has 56 states. Word has length 77 [2018-11-23 12:11:30,427 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:11:30,427 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 56 states. [2018-11-23 12:11:30,545 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 70 edges. 70 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:30,545 INFO L459 AbstractCegarLoop]: Interpolant automaton has 56 states [2018-11-23 12:11:30,545 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 56 interpolants. [2018-11-23 12:11:30,546 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1540, Invalid=1540, Unknown=0, NotChecked=0, Total=3080 [2018-11-23 12:11:30,546 INFO L87 Difference]: Start difference. First operand 81 states and 83 transitions. Second operand 56 states. [2018-11-23 12:11:32,415 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:32,415 INFO L93 Difference]: Finished difference Result 122 states and 132 transitions. [2018-11-23 12:11:32,416 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 55 states. [2018-11-23 12:11:32,416 INFO L78 Accepts]: Start accepts. Automaton has 56 states. Word has length 77 [2018-11-23 12:11:32,416 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:11:32,416 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 56 states. [2018-11-23 12:11:32,417 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 55 states to 55 states and 118 transitions. [2018-11-23 12:11:32,418 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 56 states. [2018-11-23 12:11:32,419 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 55 states to 55 states and 118 transitions. [2018-11-23 12:11:32,419 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 55 states and 118 transitions. [2018-11-23 12:11:32,520 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 118 edges. 118 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:32,522 INFO L225 Difference]: With dead ends: 122 [2018-11-23 12:11:32,522 INFO L226 Difference]: Without dead ends: 100 [2018-11-23 12:11:32,523 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 131 GetRequests, 77 SyntacticMatches, 0 SemanticMatches, 54 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 102 ImplicationChecksByTransitivity, 1.5s TimeCoverageRelationStatistics Valid=1540, Invalid=1540, Unknown=0, NotChecked=0, Total=3080 [2018-11-23 12:11:32,524 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 100 states. [2018-11-23 12:11:32,594 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 100 to 82. [2018-11-23 12:11:32,594 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:11:32,594 INFO L82 GeneralOperation]: Start isEquivalent. First operand 100 states. Second operand 82 states. [2018-11-23 12:11:32,594 INFO L74 IsIncluded]: Start isIncluded. First operand 100 states. Second operand 82 states. [2018-11-23 12:11:32,594 INFO L87 Difference]: Start difference. First operand 100 states. Second operand 82 states. [2018-11-23 12:11:32,596 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:32,597 INFO L93 Difference]: Finished difference Result 100 states and 108 transitions. [2018-11-23 12:11:32,597 INFO L276 IsEmpty]: Start isEmpty. Operand 100 states and 108 transitions. [2018-11-23 12:11:32,597 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:32,597 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:32,597 INFO L74 IsIncluded]: Start isIncluded. First operand 82 states. Second operand 100 states. [2018-11-23 12:11:32,598 INFO L87 Difference]: Start difference. First operand 82 states. Second operand 100 states. [2018-11-23 12:11:32,599 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:32,599 INFO L93 Difference]: Finished difference Result 100 states and 108 transitions. [2018-11-23 12:11:32,600 INFO L276 IsEmpty]: Start isEmpty. Operand 100 states and 108 transitions. [2018-11-23 12:11:32,600 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:32,600 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:32,600 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:11:32,600 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:11:32,601 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 82 states. [2018-11-23 12:11:32,602 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 82 states to 82 states and 84 transitions. [2018-11-23 12:11:32,602 INFO L78 Accepts]: Start accepts. Automaton has 82 states and 84 transitions. Word has length 77 [2018-11-23 12:11:32,602 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:11:32,602 INFO L480 AbstractCegarLoop]: Abstraction has 82 states and 84 transitions. [2018-11-23 12:11:32,602 INFO L481 AbstractCegarLoop]: Interpolant automaton has 56 states. [2018-11-23 12:11:32,602 INFO L276 IsEmpty]: Start isEmpty. Operand 82 states and 84 transitions. [2018-11-23 12:11:32,603 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 79 [2018-11-23 12:11:32,603 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:11:32,603 INFO L402 BasicCegarLoop]: trace histogram [53, 10, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:11:32,604 INFO L423 AbstractCegarLoop]: === Iteration 30 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:11:32,604 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:11:32,604 INFO L82 PathProgramCache]: Analyzing trace with hash -1604720726, now seen corresponding path program 27 times [2018-11-23 12:11:32,604 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:11:32,604 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:11:32,605 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:32,605 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:11:32,605 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:32,666 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:34,346 INFO L256 TraceCheckUtils]: 0: Hoare triple {13331#true} call ULTIMATE.init(); {13331#true} is VALID [2018-11-23 12:11:34,347 INFO L273 TraceCheckUtils]: 1: Hoare triple {13331#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {13331#true} is VALID [2018-11-23 12:11:34,347 INFO L273 TraceCheckUtils]: 2: Hoare triple {13331#true} assume true; {13331#true} is VALID [2018-11-23 12:11:34,347 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {13331#true} {13331#true} #60#return; {13331#true} is VALID [2018-11-23 12:11:34,347 INFO L256 TraceCheckUtils]: 4: Hoare triple {13331#true} call #t~ret4 := main(); {13331#true} is VALID [2018-11-23 12:11:34,348 INFO L273 TraceCheckUtils]: 5: Hoare triple {13331#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {13333#(= main_~i~0 0)} is VALID [2018-11-23 12:11:34,349 INFO L273 TraceCheckUtils]: 6: Hoare triple {13333#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13334#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:34,350 INFO L273 TraceCheckUtils]: 7: Hoare triple {13334#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13335#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:34,351 INFO L273 TraceCheckUtils]: 8: Hoare triple {13335#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13336#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:34,352 INFO L273 TraceCheckUtils]: 9: Hoare triple {13336#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13337#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:34,353 INFO L273 TraceCheckUtils]: 10: Hoare triple {13337#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13338#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:34,354 INFO L273 TraceCheckUtils]: 11: Hoare triple {13338#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13339#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:34,355 INFO L273 TraceCheckUtils]: 12: Hoare triple {13339#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13340#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:34,356 INFO L273 TraceCheckUtils]: 13: Hoare triple {13340#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13341#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:34,357 INFO L273 TraceCheckUtils]: 14: Hoare triple {13341#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13342#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:34,358 INFO L273 TraceCheckUtils]: 15: Hoare triple {13342#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13343#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:34,359 INFO L273 TraceCheckUtils]: 16: Hoare triple {13343#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13344#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:34,360 INFO L273 TraceCheckUtils]: 17: Hoare triple {13344#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13345#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:34,361 INFO L273 TraceCheckUtils]: 18: Hoare triple {13345#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13346#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:34,362 INFO L273 TraceCheckUtils]: 19: Hoare triple {13346#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13347#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:34,363 INFO L273 TraceCheckUtils]: 20: Hoare triple {13347#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13348#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:34,364 INFO L273 TraceCheckUtils]: 21: Hoare triple {13348#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13349#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:34,365 INFO L273 TraceCheckUtils]: 22: Hoare triple {13349#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13350#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:34,366 INFO L273 TraceCheckUtils]: 23: Hoare triple {13350#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13351#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:34,367 INFO L273 TraceCheckUtils]: 24: Hoare triple {13351#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13352#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:34,368 INFO L273 TraceCheckUtils]: 25: Hoare triple {13352#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13353#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:34,369 INFO L273 TraceCheckUtils]: 26: Hoare triple {13353#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13354#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:34,370 INFO L273 TraceCheckUtils]: 27: Hoare triple {13354#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13355#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:34,371 INFO L273 TraceCheckUtils]: 28: Hoare triple {13355#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13356#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:34,372 INFO L273 TraceCheckUtils]: 29: Hoare triple {13356#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13357#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:34,373 INFO L273 TraceCheckUtils]: 30: Hoare triple {13357#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13358#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:34,374 INFO L273 TraceCheckUtils]: 31: Hoare triple {13358#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13359#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:34,375 INFO L273 TraceCheckUtils]: 32: Hoare triple {13359#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13360#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:34,376 INFO L273 TraceCheckUtils]: 33: Hoare triple {13360#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13361#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:34,377 INFO L273 TraceCheckUtils]: 34: Hoare triple {13361#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13362#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:34,378 INFO L273 TraceCheckUtils]: 35: Hoare triple {13362#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13363#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:34,379 INFO L273 TraceCheckUtils]: 36: Hoare triple {13363#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13364#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:34,380 INFO L273 TraceCheckUtils]: 37: Hoare triple {13364#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13365#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:34,381 INFO L273 TraceCheckUtils]: 38: Hoare triple {13365#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13366#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:34,382 INFO L273 TraceCheckUtils]: 39: Hoare triple {13366#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13367#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:34,383 INFO L273 TraceCheckUtils]: 40: Hoare triple {13367#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13368#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:34,384 INFO L273 TraceCheckUtils]: 41: Hoare triple {13368#(<= main_~i~0 35)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13369#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:34,385 INFO L273 TraceCheckUtils]: 42: Hoare triple {13369#(<= main_~i~0 36)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13370#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:34,386 INFO L273 TraceCheckUtils]: 43: Hoare triple {13370#(<= main_~i~0 37)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13371#(<= main_~i~0 38)} is VALID [2018-11-23 12:11:34,387 INFO L273 TraceCheckUtils]: 44: Hoare triple {13371#(<= main_~i~0 38)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13372#(<= main_~i~0 39)} is VALID [2018-11-23 12:11:34,388 INFO L273 TraceCheckUtils]: 45: Hoare triple {13372#(<= main_~i~0 39)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13373#(<= main_~i~0 40)} is VALID [2018-11-23 12:11:34,389 INFO L273 TraceCheckUtils]: 46: Hoare triple {13373#(<= main_~i~0 40)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13374#(<= main_~i~0 41)} is VALID [2018-11-23 12:11:34,390 INFO L273 TraceCheckUtils]: 47: Hoare triple {13374#(<= main_~i~0 41)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13375#(<= main_~i~0 42)} is VALID [2018-11-23 12:11:34,391 INFO L273 TraceCheckUtils]: 48: Hoare triple {13375#(<= main_~i~0 42)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13376#(<= main_~i~0 43)} is VALID [2018-11-23 12:11:34,392 INFO L273 TraceCheckUtils]: 49: Hoare triple {13376#(<= main_~i~0 43)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13377#(<= main_~i~0 44)} is VALID [2018-11-23 12:11:34,393 INFO L273 TraceCheckUtils]: 50: Hoare triple {13377#(<= main_~i~0 44)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13378#(<= main_~i~0 45)} is VALID [2018-11-23 12:11:34,394 INFO L273 TraceCheckUtils]: 51: Hoare triple {13378#(<= main_~i~0 45)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13379#(<= main_~i~0 46)} is VALID [2018-11-23 12:11:34,395 INFO L273 TraceCheckUtils]: 52: Hoare triple {13379#(<= main_~i~0 46)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13380#(<= main_~i~0 47)} is VALID [2018-11-23 12:11:34,396 INFO L273 TraceCheckUtils]: 53: Hoare triple {13380#(<= main_~i~0 47)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13381#(<= main_~i~0 48)} is VALID [2018-11-23 12:11:34,397 INFO L273 TraceCheckUtils]: 54: Hoare triple {13381#(<= main_~i~0 48)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13382#(<= main_~i~0 49)} is VALID [2018-11-23 12:11:34,398 INFO L273 TraceCheckUtils]: 55: Hoare triple {13382#(<= main_~i~0 49)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13383#(<= main_~i~0 50)} is VALID [2018-11-23 12:11:34,399 INFO L273 TraceCheckUtils]: 56: Hoare triple {13383#(<= main_~i~0 50)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13384#(<= main_~i~0 51)} is VALID [2018-11-23 12:11:34,400 INFO L273 TraceCheckUtils]: 57: Hoare triple {13384#(<= main_~i~0 51)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13385#(<= main_~i~0 52)} is VALID [2018-11-23 12:11:34,401 INFO L273 TraceCheckUtils]: 58: Hoare triple {13385#(<= main_~i~0 52)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13386#(<= main_~i~0 53)} is VALID [2018-11-23 12:11:34,402 INFO L273 TraceCheckUtils]: 59: Hoare triple {13386#(<= main_~i~0 53)} assume !(~i~0 < 100000); {13332#false} is VALID [2018-11-23 12:11:34,402 INFO L273 TraceCheckUtils]: 60: Hoare triple {13332#false} ~i~0 := 1; {13332#false} is VALID [2018-11-23 12:11:34,402 INFO L273 TraceCheckUtils]: 61: Hoare triple {13332#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13332#false} is VALID [2018-11-23 12:11:34,402 INFO L273 TraceCheckUtils]: 62: Hoare triple {13332#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13332#false} is VALID [2018-11-23 12:11:34,403 INFO L273 TraceCheckUtils]: 63: Hoare triple {13332#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13332#false} is VALID [2018-11-23 12:11:34,403 INFO L273 TraceCheckUtils]: 64: Hoare triple {13332#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13332#false} is VALID [2018-11-23 12:11:34,403 INFO L273 TraceCheckUtils]: 65: Hoare triple {13332#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13332#false} is VALID [2018-11-23 12:11:34,403 INFO L273 TraceCheckUtils]: 66: Hoare triple {13332#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13332#false} is VALID [2018-11-23 12:11:34,403 INFO L273 TraceCheckUtils]: 67: Hoare triple {13332#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13332#false} is VALID [2018-11-23 12:11:34,403 INFO L273 TraceCheckUtils]: 68: Hoare triple {13332#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13332#false} is VALID [2018-11-23 12:11:34,404 INFO L273 TraceCheckUtils]: 69: Hoare triple {13332#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13332#false} is VALID [2018-11-23 12:11:34,404 INFO L273 TraceCheckUtils]: 70: Hoare triple {13332#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13332#false} is VALID [2018-11-23 12:11:34,404 INFO L273 TraceCheckUtils]: 71: Hoare triple {13332#false} assume !(~i~0 < 100000); {13332#false} is VALID [2018-11-23 12:11:34,404 INFO L273 TraceCheckUtils]: 72: Hoare triple {13332#false} ~i~0 := 1;~j~0 := 0; {13332#false} is VALID [2018-11-23 12:11:34,404 INFO L273 TraceCheckUtils]: 73: Hoare triple {13332#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {13332#false} is VALID [2018-11-23 12:11:34,405 INFO L256 TraceCheckUtils]: 74: Hoare triple {13332#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {13332#false} is VALID [2018-11-23 12:11:34,405 INFO L273 TraceCheckUtils]: 75: Hoare triple {13332#false} ~cond := #in~cond; {13332#false} is VALID [2018-11-23 12:11:34,405 INFO L273 TraceCheckUtils]: 76: Hoare triple {13332#false} assume 0 == ~cond; {13332#false} is VALID [2018-11-23 12:11:34,405 INFO L273 TraceCheckUtils]: 77: Hoare triple {13332#false} assume !false; {13332#false} is VALID [2018-11-23 12:11:34,409 INFO L134 CoverageAnalysis]: Checked inductivity of 1486 backedges. 0 proven. 1431 refuted. 0 times theorem prover too weak. 55 trivial. 0 not checked. [2018-11-23 12:11:34,409 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:11:34,409 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 28 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 28 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:11:34,421 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:11:34,870 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 6 check-sat command(s) [2018-11-23 12:11:34,870 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:11:34,890 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:34,892 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:11:35,188 INFO L256 TraceCheckUtils]: 0: Hoare triple {13331#true} call ULTIMATE.init(); {13331#true} is VALID [2018-11-23 12:11:35,188 INFO L273 TraceCheckUtils]: 1: Hoare triple {13331#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {13331#true} is VALID [2018-11-23 12:11:35,188 INFO L273 TraceCheckUtils]: 2: Hoare triple {13331#true} assume true; {13331#true} is VALID [2018-11-23 12:11:35,189 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {13331#true} {13331#true} #60#return; {13331#true} is VALID [2018-11-23 12:11:35,189 INFO L256 TraceCheckUtils]: 4: Hoare triple {13331#true} call #t~ret4 := main(); {13331#true} is VALID [2018-11-23 12:11:35,189 INFO L273 TraceCheckUtils]: 5: Hoare triple {13331#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {13331#true} is VALID [2018-11-23 12:11:35,189 INFO L273 TraceCheckUtils]: 6: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,189 INFO L273 TraceCheckUtils]: 7: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,190 INFO L273 TraceCheckUtils]: 8: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,190 INFO L273 TraceCheckUtils]: 9: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,190 INFO L273 TraceCheckUtils]: 10: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,190 INFO L273 TraceCheckUtils]: 11: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,190 INFO L273 TraceCheckUtils]: 12: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,190 INFO L273 TraceCheckUtils]: 13: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,191 INFO L273 TraceCheckUtils]: 14: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,191 INFO L273 TraceCheckUtils]: 15: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,191 INFO L273 TraceCheckUtils]: 16: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,191 INFO L273 TraceCheckUtils]: 17: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,191 INFO L273 TraceCheckUtils]: 18: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,191 INFO L273 TraceCheckUtils]: 19: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,191 INFO L273 TraceCheckUtils]: 20: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,191 INFO L273 TraceCheckUtils]: 21: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,191 INFO L273 TraceCheckUtils]: 22: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,192 INFO L273 TraceCheckUtils]: 23: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,192 INFO L273 TraceCheckUtils]: 24: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,192 INFO L273 TraceCheckUtils]: 25: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,192 INFO L273 TraceCheckUtils]: 26: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,192 INFO L273 TraceCheckUtils]: 27: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,192 INFO L273 TraceCheckUtils]: 28: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,192 INFO L273 TraceCheckUtils]: 29: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,192 INFO L273 TraceCheckUtils]: 30: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,192 INFO L273 TraceCheckUtils]: 31: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,193 INFO L273 TraceCheckUtils]: 32: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,193 INFO L273 TraceCheckUtils]: 33: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,193 INFO L273 TraceCheckUtils]: 34: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,193 INFO L273 TraceCheckUtils]: 35: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,193 INFO L273 TraceCheckUtils]: 36: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,193 INFO L273 TraceCheckUtils]: 37: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,193 INFO L273 TraceCheckUtils]: 38: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,193 INFO L273 TraceCheckUtils]: 39: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,193 INFO L273 TraceCheckUtils]: 40: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,194 INFO L273 TraceCheckUtils]: 41: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,194 INFO L273 TraceCheckUtils]: 42: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,194 INFO L273 TraceCheckUtils]: 43: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,194 INFO L273 TraceCheckUtils]: 44: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,194 INFO L273 TraceCheckUtils]: 45: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,194 INFO L273 TraceCheckUtils]: 46: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,194 INFO L273 TraceCheckUtils]: 47: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,194 INFO L273 TraceCheckUtils]: 48: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,195 INFO L273 TraceCheckUtils]: 49: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,195 INFO L273 TraceCheckUtils]: 50: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,195 INFO L273 TraceCheckUtils]: 51: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,195 INFO L273 TraceCheckUtils]: 52: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,195 INFO L273 TraceCheckUtils]: 53: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,195 INFO L273 TraceCheckUtils]: 54: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,195 INFO L273 TraceCheckUtils]: 55: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,195 INFO L273 TraceCheckUtils]: 56: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,195 INFO L273 TraceCheckUtils]: 57: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,196 INFO L273 TraceCheckUtils]: 58: Hoare triple {13331#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13331#true} is VALID [2018-11-23 12:11:35,196 INFO L273 TraceCheckUtils]: 59: Hoare triple {13331#true} assume !(~i~0 < 100000); {13331#true} is VALID [2018-11-23 12:11:35,196 INFO L273 TraceCheckUtils]: 60: Hoare triple {13331#true} ~i~0 := 1; {13334#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:35,197 INFO L273 TraceCheckUtils]: 61: Hoare triple {13334#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13343#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:35,197 INFO L273 TraceCheckUtils]: 62: Hoare triple {13343#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13352#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:35,198 INFO L273 TraceCheckUtils]: 63: Hoare triple {13352#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13361#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:35,199 INFO L273 TraceCheckUtils]: 64: Hoare triple {13361#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13370#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:35,199 INFO L273 TraceCheckUtils]: 65: Hoare triple {13370#(<= main_~i~0 37)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13379#(<= main_~i~0 46)} is VALID [2018-11-23 12:11:35,200 INFO L273 TraceCheckUtils]: 66: Hoare triple {13379#(<= main_~i~0 46)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13588#(<= main_~i~0 55)} is VALID [2018-11-23 12:11:35,201 INFO L273 TraceCheckUtils]: 67: Hoare triple {13588#(<= main_~i~0 55)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13592#(<= main_~i~0 64)} is VALID [2018-11-23 12:11:35,203 INFO L273 TraceCheckUtils]: 68: Hoare triple {13592#(<= main_~i~0 64)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13596#(<= main_~i~0 73)} is VALID [2018-11-23 12:11:35,204 INFO L273 TraceCheckUtils]: 69: Hoare triple {13596#(<= main_~i~0 73)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13600#(<= main_~i~0 82)} is VALID [2018-11-23 12:11:35,205 INFO L273 TraceCheckUtils]: 70: Hoare triple {13600#(<= main_~i~0 82)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {13604#(<= main_~i~0 91)} is VALID [2018-11-23 12:11:35,205 INFO L273 TraceCheckUtils]: 71: Hoare triple {13604#(<= main_~i~0 91)} assume !(~i~0 < 100000); {13332#false} is VALID [2018-11-23 12:11:35,205 INFO L273 TraceCheckUtils]: 72: Hoare triple {13332#false} ~i~0 := 1;~j~0 := 0; {13332#false} is VALID [2018-11-23 12:11:35,206 INFO L273 TraceCheckUtils]: 73: Hoare triple {13332#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {13332#false} is VALID [2018-11-23 12:11:35,206 INFO L256 TraceCheckUtils]: 74: Hoare triple {13332#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {13332#false} is VALID [2018-11-23 12:11:35,206 INFO L273 TraceCheckUtils]: 75: Hoare triple {13332#false} ~cond := #in~cond; {13332#false} is VALID [2018-11-23 12:11:35,206 INFO L273 TraceCheckUtils]: 76: Hoare triple {13332#false} assume 0 == ~cond; {13332#false} is VALID [2018-11-23 12:11:35,206 INFO L273 TraceCheckUtils]: 77: Hoare triple {13332#false} assume !false; {13332#false} is VALID [2018-11-23 12:11:35,211 INFO L134 CoverageAnalysis]: Checked inductivity of 1486 backedges. 0 proven. 55 refuted. 0 times theorem prover too weak. 1431 trivial. 0 not checked. [2018-11-23 12:11:35,230 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:11:35,231 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [56, 13] total 61 [2018-11-23 12:11:35,231 INFO L78 Accepts]: Start accepts. Automaton has 61 states. Word has length 78 [2018-11-23 12:11:35,231 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:11:35,231 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 61 states. [2018-11-23 12:11:35,304 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 84 edges. 84 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:35,305 INFO L459 AbstractCegarLoop]: Interpolant automaton has 61 states [2018-11-23 12:11:35,305 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 61 interpolants. [2018-11-23 12:11:35,307 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1830, Invalid=1830, Unknown=0, NotChecked=0, Total=3660 [2018-11-23 12:11:35,308 INFO L87 Difference]: Start difference. First operand 82 states and 84 transitions. Second operand 61 states. [2018-11-23 12:11:37,271 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:37,272 INFO L93 Difference]: Finished difference Result 144 states and 165 transitions. [2018-11-23 12:11:37,272 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 61 states. [2018-11-23 12:11:37,272 INFO L78 Accepts]: Start accepts. Automaton has 61 states. Word has length 78 [2018-11-23 12:11:37,272 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:11:37,272 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 61 states. [2018-11-23 12:11:37,274 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 61 states to 61 states and 155 transitions. [2018-11-23 12:11:37,275 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 61 states. [2018-11-23 12:11:37,277 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 61 states to 61 states and 155 transitions. [2018-11-23 12:11:37,277 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 61 states and 155 transitions. [2018-11-23 12:11:37,417 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 155 edges. 155 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:37,419 INFO L225 Difference]: With dead ends: 144 [2018-11-23 12:11:37,419 INFO L226 Difference]: Without dead ends: 122 [2018-11-23 12:11:37,421 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 133 GetRequests, 74 SyntacticMatches, 0 SemanticMatches, 59 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 1.6s TimeCoverageRelationStatistics Valid=1830, Invalid=1830, Unknown=0, NotChecked=0, Total=3660 [2018-11-23 12:11:37,421 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 122 states. [2018-11-23 12:11:37,856 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 122 to 89. [2018-11-23 12:11:37,856 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:11:37,856 INFO L82 GeneralOperation]: Start isEquivalent. First operand 122 states. Second operand 89 states. [2018-11-23 12:11:37,857 INFO L74 IsIncluded]: Start isIncluded. First operand 122 states. Second operand 89 states. [2018-11-23 12:11:37,857 INFO L87 Difference]: Start difference. First operand 122 states. Second operand 89 states. [2018-11-23 12:11:37,859 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:37,859 INFO L93 Difference]: Finished difference Result 122 states and 135 transitions. [2018-11-23 12:11:37,859 INFO L276 IsEmpty]: Start isEmpty. Operand 122 states and 135 transitions. [2018-11-23 12:11:37,860 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:37,860 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:37,860 INFO L74 IsIncluded]: Start isIncluded. First operand 89 states. Second operand 122 states. [2018-11-23 12:11:37,860 INFO L87 Difference]: Start difference. First operand 89 states. Second operand 122 states. [2018-11-23 12:11:37,862 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:37,862 INFO L93 Difference]: Finished difference Result 122 states and 135 transitions. [2018-11-23 12:11:37,863 INFO L276 IsEmpty]: Start isEmpty. Operand 122 states and 135 transitions. [2018-11-23 12:11:37,863 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:37,863 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:37,863 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:11:37,864 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:11:37,864 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 89 states. [2018-11-23 12:11:37,865 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 89 states to 89 states and 91 transitions. [2018-11-23 12:11:37,865 INFO L78 Accepts]: Start accepts. Automaton has 89 states and 91 transitions. Word has length 78 [2018-11-23 12:11:37,865 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:11:37,865 INFO L480 AbstractCegarLoop]: Abstraction has 89 states and 91 transitions. [2018-11-23 12:11:37,865 INFO L481 AbstractCegarLoop]: Interpolant automaton has 61 states. [2018-11-23 12:11:37,865 INFO L276 IsEmpty]: Start isEmpty. Operand 89 states and 91 transitions. [2018-11-23 12:11:37,866 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 86 [2018-11-23 12:11:37,866 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:11:37,866 INFO L402 BasicCegarLoop]: trace histogram [59, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:11:37,866 INFO L423 AbstractCegarLoop]: === Iteration 31 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:11:37,866 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:11:37,866 INFO L82 PathProgramCache]: Analyzing trace with hash -624870043, now seen corresponding path program 28 times [2018-11-23 12:11:37,867 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:11:37,867 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:11:37,867 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:37,867 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:11:37,868 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:37,946 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:39,533 INFO L256 TraceCheckUtils]: 0: Hoare triple {14296#true} call ULTIMATE.init(); {14296#true} is VALID [2018-11-23 12:11:39,534 INFO L273 TraceCheckUtils]: 1: Hoare triple {14296#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {14296#true} is VALID [2018-11-23 12:11:39,534 INFO L273 TraceCheckUtils]: 2: Hoare triple {14296#true} assume true; {14296#true} is VALID [2018-11-23 12:11:39,534 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {14296#true} {14296#true} #60#return; {14296#true} is VALID [2018-11-23 12:11:39,534 INFO L256 TraceCheckUtils]: 4: Hoare triple {14296#true} call #t~ret4 := main(); {14296#true} is VALID [2018-11-23 12:11:39,535 INFO L273 TraceCheckUtils]: 5: Hoare triple {14296#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {14298#(= main_~i~0 0)} is VALID [2018-11-23 12:11:39,536 INFO L273 TraceCheckUtils]: 6: Hoare triple {14298#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14299#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:39,536 INFO L273 TraceCheckUtils]: 7: Hoare triple {14299#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14300#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:39,537 INFO L273 TraceCheckUtils]: 8: Hoare triple {14300#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14301#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:39,537 INFO L273 TraceCheckUtils]: 9: Hoare triple {14301#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14302#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:39,538 INFO L273 TraceCheckUtils]: 10: Hoare triple {14302#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14303#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:39,539 INFO L273 TraceCheckUtils]: 11: Hoare triple {14303#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14304#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:39,540 INFO L273 TraceCheckUtils]: 12: Hoare triple {14304#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14305#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:39,541 INFO L273 TraceCheckUtils]: 13: Hoare triple {14305#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14306#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:39,541 INFO L273 TraceCheckUtils]: 14: Hoare triple {14306#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14307#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:39,542 INFO L273 TraceCheckUtils]: 15: Hoare triple {14307#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14308#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:39,543 INFO L273 TraceCheckUtils]: 16: Hoare triple {14308#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14309#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:39,544 INFO L273 TraceCheckUtils]: 17: Hoare triple {14309#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14310#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:39,545 INFO L273 TraceCheckUtils]: 18: Hoare triple {14310#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14311#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:39,546 INFO L273 TraceCheckUtils]: 19: Hoare triple {14311#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14312#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:39,547 INFO L273 TraceCheckUtils]: 20: Hoare triple {14312#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14313#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:39,548 INFO L273 TraceCheckUtils]: 21: Hoare triple {14313#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14314#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:39,549 INFO L273 TraceCheckUtils]: 22: Hoare triple {14314#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14315#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:39,550 INFO L273 TraceCheckUtils]: 23: Hoare triple {14315#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14316#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:39,551 INFO L273 TraceCheckUtils]: 24: Hoare triple {14316#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14317#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:39,552 INFO L273 TraceCheckUtils]: 25: Hoare triple {14317#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14318#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:39,553 INFO L273 TraceCheckUtils]: 26: Hoare triple {14318#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14319#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:39,554 INFO L273 TraceCheckUtils]: 27: Hoare triple {14319#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14320#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:39,554 INFO L273 TraceCheckUtils]: 28: Hoare triple {14320#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14321#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:39,555 INFO L273 TraceCheckUtils]: 29: Hoare triple {14321#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14322#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:39,556 INFO L273 TraceCheckUtils]: 30: Hoare triple {14322#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14323#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:39,557 INFO L273 TraceCheckUtils]: 31: Hoare triple {14323#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14324#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:39,558 INFO L273 TraceCheckUtils]: 32: Hoare triple {14324#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14325#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:39,559 INFO L273 TraceCheckUtils]: 33: Hoare triple {14325#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14326#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:39,560 INFO L273 TraceCheckUtils]: 34: Hoare triple {14326#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14327#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:39,561 INFO L273 TraceCheckUtils]: 35: Hoare triple {14327#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14328#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:39,562 INFO L273 TraceCheckUtils]: 36: Hoare triple {14328#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14329#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:39,563 INFO L273 TraceCheckUtils]: 37: Hoare triple {14329#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14330#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:39,564 INFO L273 TraceCheckUtils]: 38: Hoare triple {14330#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14331#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:39,565 INFO L273 TraceCheckUtils]: 39: Hoare triple {14331#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14332#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:39,566 INFO L273 TraceCheckUtils]: 40: Hoare triple {14332#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14333#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:39,566 INFO L273 TraceCheckUtils]: 41: Hoare triple {14333#(<= main_~i~0 35)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14334#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:39,567 INFO L273 TraceCheckUtils]: 42: Hoare triple {14334#(<= main_~i~0 36)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14335#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:39,568 INFO L273 TraceCheckUtils]: 43: Hoare triple {14335#(<= main_~i~0 37)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14336#(<= main_~i~0 38)} is VALID [2018-11-23 12:11:39,569 INFO L273 TraceCheckUtils]: 44: Hoare triple {14336#(<= main_~i~0 38)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14337#(<= main_~i~0 39)} is VALID [2018-11-23 12:11:39,570 INFO L273 TraceCheckUtils]: 45: Hoare triple {14337#(<= main_~i~0 39)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14338#(<= main_~i~0 40)} is VALID [2018-11-23 12:11:39,571 INFO L273 TraceCheckUtils]: 46: Hoare triple {14338#(<= main_~i~0 40)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14339#(<= main_~i~0 41)} is VALID [2018-11-23 12:11:39,572 INFO L273 TraceCheckUtils]: 47: Hoare triple {14339#(<= main_~i~0 41)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14340#(<= main_~i~0 42)} is VALID [2018-11-23 12:11:39,573 INFO L273 TraceCheckUtils]: 48: Hoare triple {14340#(<= main_~i~0 42)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14341#(<= main_~i~0 43)} is VALID [2018-11-23 12:11:39,574 INFO L273 TraceCheckUtils]: 49: Hoare triple {14341#(<= main_~i~0 43)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14342#(<= main_~i~0 44)} is VALID [2018-11-23 12:11:39,575 INFO L273 TraceCheckUtils]: 50: Hoare triple {14342#(<= main_~i~0 44)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14343#(<= main_~i~0 45)} is VALID [2018-11-23 12:11:39,576 INFO L273 TraceCheckUtils]: 51: Hoare triple {14343#(<= main_~i~0 45)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14344#(<= main_~i~0 46)} is VALID [2018-11-23 12:11:39,577 INFO L273 TraceCheckUtils]: 52: Hoare triple {14344#(<= main_~i~0 46)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14345#(<= main_~i~0 47)} is VALID [2018-11-23 12:11:39,578 INFO L273 TraceCheckUtils]: 53: Hoare triple {14345#(<= main_~i~0 47)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14346#(<= main_~i~0 48)} is VALID [2018-11-23 12:11:39,578 INFO L273 TraceCheckUtils]: 54: Hoare triple {14346#(<= main_~i~0 48)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14347#(<= main_~i~0 49)} is VALID [2018-11-23 12:11:39,579 INFO L273 TraceCheckUtils]: 55: Hoare triple {14347#(<= main_~i~0 49)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14348#(<= main_~i~0 50)} is VALID [2018-11-23 12:11:39,580 INFO L273 TraceCheckUtils]: 56: Hoare triple {14348#(<= main_~i~0 50)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14349#(<= main_~i~0 51)} is VALID [2018-11-23 12:11:39,581 INFO L273 TraceCheckUtils]: 57: Hoare triple {14349#(<= main_~i~0 51)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14350#(<= main_~i~0 52)} is VALID [2018-11-23 12:11:39,582 INFO L273 TraceCheckUtils]: 58: Hoare triple {14350#(<= main_~i~0 52)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14351#(<= main_~i~0 53)} is VALID [2018-11-23 12:11:39,583 INFO L273 TraceCheckUtils]: 59: Hoare triple {14351#(<= main_~i~0 53)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14352#(<= main_~i~0 54)} is VALID [2018-11-23 12:11:39,584 INFO L273 TraceCheckUtils]: 60: Hoare triple {14352#(<= main_~i~0 54)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14353#(<= main_~i~0 55)} is VALID [2018-11-23 12:11:39,585 INFO L273 TraceCheckUtils]: 61: Hoare triple {14353#(<= main_~i~0 55)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14354#(<= main_~i~0 56)} is VALID [2018-11-23 12:11:39,586 INFO L273 TraceCheckUtils]: 62: Hoare triple {14354#(<= main_~i~0 56)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14355#(<= main_~i~0 57)} is VALID [2018-11-23 12:11:39,587 INFO L273 TraceCheckUtils]: 63: Hoare triple {14355#(<= main_~i~0 57)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14356#(<= main_~i~0 58)} is VALID [2018-11-23 12:11:39,588 INFO L273 TraceCheckUtils]: 64: Hoare triple {14356#(<= main_~i~0 58)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14357#(<= main_~i~0 59)} is VALID [2018-11-23 12:11:39,588 INFO L273 TraceCheckUtils]: 65: Hoare triple {14357#(<= main_~i~0 59)} assume !(~i~0 < 100000); {14297#false} is VALID [2018-11-23 12:11:39,589 INFO L273 TraceCheckUtils]: 66: Hoare triple {14297#false} ~i~0 := 1; {14297#false} is VALID [2018-11-23 12:11:39,589 INFO L273 TraceCheckUtils]: 67: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:39,589 INFO L273 TraceCheckUtils]: 68: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:39,589 INFO L273 TraceCheckUtils]: 69: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:39,589 INFO L273 TraceCheckUtils]: 70: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:39,589 INFO L273 TraceCheckUtils]: 71: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:39,590 INFO L273 TraceCheckUtils]: 72: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:39,590 INFO L273 TraceCheckUtils]: 73: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:39,590 INFO L273 TraceCheckUtils]: 74: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:39,590 INFO L273 TraceCheckUtils]: 75: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:39,590 INFO L273 TraceCheckUtils]: 76: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:39,591 INFO L273 TraceCheckUtils]: 77: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:39,591 INFO L273 TraceCheckUtils]: 78: Hoare triple {14297#false} assume !(~i~0 < 100000); {14297#false} is VALID [2018-11-23 12:11:39,591 INFO L273 TraceCheckUtils]: 79: Hoare triple {14297#false} ~i~0 := 1;~j~0 := 0; {14297#false} is VALID [2018-11-23 12:11:39,591 INFO L273 TraceCheckUtils]: 80: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {14297#false} is VALID [2018-11-23 12:11:39,591 INFO L256 TraceCheckUtils]: 81: Hoare triple {14297#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {14297#false} is VALID [2018-11-23 12:11:39,592 INFO L273 TraceCheckUtils]: 82: Hoare triple {14297#false} ~cond := #in~cond; {14297#false} is VALID [2018-11-23 12:11:39,592 INFO L273 TraceCheckUtils]: 83: Hoare triple {14297#false} assume 0 == ~cond; {14297#false} is VALID [2018-11-23 12:11:39,592 INFO L273 TraceCheckUtils]: 84: Hoare triple {14297#false} assume !false; {14297#false} is VALID [2018-11-23 12:11:39,597 INFO L134 CoverageAnalysis]: Checked inductivity of 1836 backedges. 0 proven. 1770 refuted. 0 times theorem prover too weak. 66 trivial. 0 not checked. [2018-11-23 12:11:39,598 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:11:39,598 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 29 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 29 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:11:39,607 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:11:39,680 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:11:39,681 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:11:39,705 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:39,707 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:11:40,087 INFO L256 TraceCheckUtils]: 0: Hoare triple {14296#true} call ULTIMATE.init(); {14296#true} is VALID [2018-11-23 12:11:40,088 INFO L273 TraceCheckUtils]: 1: Hoare triple {14296#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {14296#true} is VALID [2018-11-23 12:11:40,088 INFO L273 TraceCheckUtils]: 2: Hoare triple {14296#true} assume true; {14296#true} is VALID [2018-11-23 12:11:40,088 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {14296#true} {14296#true} #60#return; {14296#true} is VALID [2018-11-23 12:11:40,088 INFO L256 TraceCheckUtils]: 4: Hoare triple {14296#true} call #t~ret4 := main(); {14296#true} is VALID [2018-11-23 12:11:40,089 INFO L273 TraceCheckUtils]: 5: Hoare triple {14296#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {14376#(<= main_~i~0 0)} is VALID [2018-11-23 12:11:40,090 INFO L273 TraceCheckUtils]: 6: Hoare triple {14376#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14299#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:40,090 INFO L273 TraceCheckUtils]: 7: Hoare triple {14299#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14300#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:40,091 INFO L273 TraceCheckUtils]: 8: Hoare triple {14300#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14301#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:40,092 INFO L273 TraceCheckUtils]: 9: Hoare triple {14301#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14302#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:40,092 INFO L273 TraceCheckUtils]: 10: Hoare triple {14302#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14303#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:40,093 INFO L273 TraceCheckUtils]: 11: Hoare triple {14303#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14304#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:40,094 INFO L273 TraceCheckUtils]: 12: Hoare triple {14304#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14305#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:40,095 INFO L273 TraceCheckUtils]: 13: Hoare triple {14305#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14306#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:40,096 INFO L273 TraceCheckUtils]: 14: Hoare triple {14306#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14307#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:40,097 INFO L273 TraceCheckUtils]: 15: Hoare triple {14307#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14308#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:40,098 INFO L273 TraceCheckUtils]: 16: Hoare triple {14308#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14309#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:40,099 INFO L273 TraceCheckUtils]: 17: Hoare triple {14309#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14310#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:40,100 INFO L273 TraceCheckUtils]: 18: Hoare triple {14310#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14311#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:40,101 INFO L273 TraceCheckUtils]: 19: Hoare triple {14311#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14312#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:40,102 INFO L273 TraceCheckUtils]: 20: Hoare triple {14312#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14313#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:40,102 INFO L273 TraceCheckUtils]: 21: Hoare triple {14313#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14314#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:40,103 INFO L273 TraceCheckUtils]: 22: Hoare triple {14314#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14315#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:40,104 INFO L273 TraceCheckUtils]: 23: Hoare triple {14315#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14316#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:40,105 INFO L273 TraceCheckUtils]: 24: Hoare triple {14316#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14317#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:40,106 INFO L273 TraceCheckUtils]: 25: Hoare triple {14317#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14318#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:40,107 INFO L273 TraceCheckUtils]: 26: Hoare triple {14318#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14319#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:40,108 INFO L273 TraceCheckUtils]: 27: Hoare triple {14319#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14320#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:40,109 INFO L273 TraceCheckUtils]: 28: Hoare triple {14320#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14321#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:40,110 INFO L273 TraceCheckUtils]: 29: Hoare triple {14321#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14322#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:40,111 INFO L273 TraceCheckUtils]: 30: Hoare triple {14322#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14323#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:40,112 INFO L273 TraceCheckUtils]: 31: Hoare triple {14323#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14324#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:40,113 INFO L273 TraceCheckUtils]: 32: Hoare triple {14324#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14325#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:40,114 INFO L273 TraceCheckUtils]: 33: Hoare triple {14325#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14326#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:40,115 INFO L273 TraceCheckUtils]: 34: Hoare triple {14326#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14327#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:40,116 INFO L273 TraceCheckUtils]: 35: Hoare triple {14327#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14328#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:40,117 INFO L273 TraceCheckUtils]: 36: Hoare triple {14328#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14329#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:40,118 INFO L273 TraceCheckUtils]: 37: Hoare triple {14329#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14330#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:40,119 INFO L273 TraceCheckUtils]: 38: Hoare triple {14330#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14331#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:40,120 INFO L273 TraceCheckUtils]: 39: Hoare triple {14331#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14332#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:40,121 INFO L273 TraceCheckUtils]: 40: Hoare triple {14332#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14333#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:40,122 INFO L273 TraceCheckUtils]: 41: Hoare triple {14333#(<= main_~i~0 35)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14334#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:40,123 INFO L273 TraceCheckUtils]: 42: Hoare triple {14334#(<= main_~i~0 36)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14335#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:40,124 INFO L273 TraceCheckUtils]: 43: Hoare triple {14335#(<= main_~i~0 37)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14336#(<= main_~i~0 38)} is VALID [2018-11-23 12:11:40,125 INFO L273 TraceCheckUtils]: 44: Hoare triple {14336#(<= main_~i~0 38)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14337#(<= main_~i~0 39)} is VALID [2018-11-23 12:11:40,126 INFO L273 TraceCheckUtils]: 45: Hoare triple {14337#(<= main_~i~0 39)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14338#(<= main_~i~0 40)} is VALID [2018-11-23 12:11:40,127 INFO L273 TraceCheckUtils]: 46: Hoare triple {14338#(<= main_~i~0 40)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14339#(<= main_~i~0 41)} is VALID [2018-11-23 12:11:40,128 INFO L273 TraceCheckUtils]: 47: Hoare triple {14339#(<= main_~i~0 41)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14340#(<= main_~i~0 42)} is VALID [2018-11-23 12:11:40,129 INFO L273 TraceCheckUtils]: 48: Hoare triple {14340#(<= main_~i~0 42)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14341#(<= main_~i~0 43)} is VALID [2018-11-23 12:11:40,130 INFO L273 TraceCheckUtils]: 49: Hoare triple {14341#(<= main_~i~0 43)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14342#(<= main_~i~0 44)} is VALID [2018-11-23 12:11:40,130 INFO L273 TraceCheckUtils]: 50: Hoare triple {14342#(<= main_~i~0 44)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14343#(<= main_~i~0 45)} is VALID [2018-11-23 12:11:40,131 INFO L273 TraceCheckUtils]: 51: Hoare triple {14343#(<= main_~i~0 45)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14344#(<= main_~i~0 46)} is VALID [2018-11-23 12:11:40,132 INFO L273 TraceCheckUtils]: 52: Hoare triple {14344#(<= main_~i~0 46)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14345#(<= main_~i~0 47)} is VALID [2018-11-23 12:11:40,133 INFO L273 TraceCheckUtils]: 53: Hoare triple {14345#(<= main_~i~0 47)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14346#(<= main_~i~0 48)} is VALID [2018-11-23 12:11:40,134 INFO L273 TraceCheckUtils]: 54: Hoare triple {14346#(<= main_~i~0 48)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14347#(<= main_~i~0 49)} is VALID [2018-11-23 12:11:40,135 INFO L273 TraceCheckUtils]: 55: Hoare triple {14347#(<= main_~i~0 49)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14348#(<= main_~i~0 50)} is VALID [2018-11-23 12:11:40,136 INFO L273 TraceCheckUtils]: 56: Hoare triple {14348#(<= main_~i~0 50)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14349#(<= main_~i~0 51)} is VALID [2018-11-23 12:11:40,137 INFO L273 TraceCheckUtils]: 57: Hoare triple {14349#(<= main_~i~0 51)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14350#(<= main_~i~0 52)} is VALID [2018-11-23 12:11:40,138 INFO L273 TraceCheckUtils]: 58: Hoare triple {14350#(<= main_~i~0 52)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14351#(<= main_~i~0 53)} is VALID [2018-11-23 12:11:40,139 INFO L273 TraceCheckUtils]: 59: Hoare triple {14351#(<= main_~i~0 53)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14352#(<= main_~i~0 54)} is VALID [2018-11-23 12:11:40,140 INFO L273 TraceCheckUtils]: 60: Hoare triple {14352#(<= main_~i~0 54)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14353#(<= main_~i~0 55)} is VALID [2018-11-23 12:11:40,141 INFO L273 TraceCheckUtils]: 61: Hoare triple {14353#(<= main_~i~0 55)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14354#(<= main_~i~0 56)} is VALID [2018-11-23 12:11:40,142 INFO L273 TraceCheckUtils]: 62: Hoare triple {14354#(<= main_~i~0 56)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14355#(<= main_~i~0 57)} is VALID [2018-11-23 12:11:40,143 INFO L273 TraceCheckUtils]: 63: Hoare triple {14355#(<= main_~i~0 57)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14356#(<= main_~i~0 58)} is VALID [2018-11-23 12:11:40,144 INFO L273 TraceCheckUtils]: 64: Hoare triple {14356#(<= main_~i~0 58)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {14357#(<= main_~i~0 59)} is VALID [2018-11-23 12:11:40,145 INFO L273 TraceCheckUtils]: 65: Hoare triple {14357#(<= main_~i~0 59)} assume !(~i~0 < 100000); {14297#false} is VALID [2018-11-23 12:11:40,145 INFO L273 TraceCheckUtils]: 66: Hoare triple {14297#false} ~i~0 := 1; {14297#false} is VALID [2018-11-23 12:11:40,145 INFO L273 TraceCheckUtils]: 67: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:40,145 INFO L273 TraceCheckUtils]: 68: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:40,145 INFO L273 TraceCheckUtils]: 69: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:40,146 INFO L273 TraceCheckUtils]: 70: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:40,146 INFO L273 TraceCheckUtils]: 71: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:40,146 INFO L273 TraceCheckUtils]: 72: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:40,146 INFO L273 TraceCheckUtils]: 73: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:40,146 INFO L273 TraceCheckUtils]: 74: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:40,147 INFO L273 TraceCheckUtils]: 75: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:40,147 INFO L273 TraceCheckUtils]: 76: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:40,147 INFO L273 TraceCheckUtils]: 77: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {14297#false} is VALID [2018-11-23 12:11:40,147 INFO L273 TraceCheckUtils]: 78: Hoare triple {14297#false} assume !(~i~0 < 100000); {14297#false} is VALID [2018-11-23 12:11:40,147 INFO L273 TraceCheckUtils]: 79: Hoare triple {14297#false} ~i~0 := 1;~j~0 := 0; {14297#false} is VALID [2018-11-23 12:11:40,148 INFO L273 TraceCheckUtils]: 80: Hoare triple {14297#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {14297#false} is VALID [2018-11-23 12:11:40,148 INFO L256 TraceCheckUtils]: 81: Hoare triple {14297#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {14297#false} is VALID [2018-11-23 12:11:40,148 INFO L273 TraceCheckUtils]: 82: Hoare triple {14297#false} ~cond := #in~cond; {14297#false} is VALID [2018-11-23 12:11:40,148 INFO L273 TraceCheckUtils]: 83: Hoare triple {14297#false} assume 0 == ~cond; {14297#false} is VALID [2018-11-23 12:11:40,148 INFO L273 TraceCheckUtils]: 84: Hoare triple {14297#false} assume !false; {14297#false} is VALID [2018-11-23 12:11:40,153 INFO L134 CoverageAnalysis]: Checked inductivity of 1836 backedges. 0 proven. 1770 refuted. 0 times theorem prover too weak. 66 trivial. 0 not checked. [2018-11-23 12:11:40,172 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:11:40,172 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [62, 62] total 63 [2018-11-23 12:11:40,172 INFO L78 Accepts]: Start accepts. Automaton has 63 states. Word has length 85 [2018-11-23 12:11:40,172 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:11:40,173 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 63 states. [2018-11-23 12:11:40,232 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 77 edges. 77 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:40,232 INFO L459 AbstractCegarLoop]: Interpolant automaton has 63 states [2018-11-23 12:11:40,232 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 63 interpolants. [2018-11-23 12:11:40,233 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1953, Invalid=1953, Unknown=0, NotChecked=0, Total=3906 [2018-11-23 12:11:40,234 INFO L87 Difference]: Start difference. First operand 89 states and 91 transitions. Second operand 63 states. [2018-11-23 12:11:41,900 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:41,900 INFO L93 Difference]: Finished difference Result 134 states and 145 transitions. [2018-11-23 12:11:41,901 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 62 states. [2018-11-23 12:11:41,901 INFO L78 Accepts]: Start accepts. Automaton has 63 states. Word has length 85 [2018-11-23 12:11:41,901 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:11:41,901 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 63 states. [2018-11-23 12:11:41,902 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 62 states to 62 states and 130 transitions. [2018-11-23 12:11:41,902 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 63 states. [2018-11-23 12:11:41,904 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 62 states to 62 states and 130 transitions. [2018-11-23 12:11:41,904 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 62 states and 130 transitions. [2018-11-23 12:11:42,013 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 130 edges. 130 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:42,015 INFO L225 Difference]: With dead ends: 134 [2018-11-23 12:11:42,015 INFO L226 Difference]: Without dead ends: 111 [2018-11-23 12:11:42,016 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 146 GetRequests, 85 SyntacticMatches, 0 SemanticMatches, 61 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 116 ImplicationChecksByTransitivity, 1.3s TimeCoverageRelationStatistics Valid=1953, Invalid=1953, Unknown=0, NotChecked=0, Total=3906 [2018-11-23 12:11:42,016 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 111 states. [2018-11-23 12:11:42,086 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 111 to 90. [2018-11-23 12:11:42,086 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:11:42,086 INFO L82 GeneralOperation]: Start isEquivalent. First operand 111 states. Second operand 90 states. [2018-11-23 12:11:42,087 INFO L74 IsIncluded]: Start isIncluded. First operand 111 states. Second operand 90 states. [2018-11-23 12:11:42,087 INFO L87 Difference]: Start difference. First operand 111 states. Second operand 90 states. [2018-11-23 12:11:42,089 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:42,089 INFO L93 Difference]: Finished difference Result 111 states and 120 transitions. [2018-11-23 12:11:42,089 INFO L276 IsEmpty]: Start isEmpty. Operand 111 states and 120 transitions. [2018-11-23 12:11:42,089 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:42,089 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:42,090 INFO L74 IsIncluded]: Start isIncluded. First operand 90 states. Second operand 111 states. [2018-11-23 12:11:42,090 INFO L87 Difference]: Start difference. First operand 90 states. Second operand 111 states. [2018-11-23 12:11:42,091 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:42,091 INFO L93 Difference]: Finished difference Result 111 states and 120 transitions. [2018-11-23 12:11:42,091 INFO L276 IsEmpty]: Start isEmpty. Operand 111 states and 120 transitions. [2018-11-23 12:11:42,092 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:42,092 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:42,092 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:11:42,092 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:11:42,092 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 90 states. [2018-11-23 12:11:42,093 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 90 states to 90 states and 92 transitions. [2018-11-23 12:11:42,093 INFO L78 Accepts]: Start accepts. Automaton has 90 states and 92 transitions. Word has length 85 [2018-11-23 12:11:42,094 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:11:42,094 INFO L480 AbstractCegarLoop]: Abstraction has 90 states and 92 transitions. [2018-11-23 12:11:42,094 INFO L481 AbstractCegarLoop]: Interpolant automaton has 63 states. [2018-11-23 12:11:42,094 INFO L276 IsEmpty]: Start isEmpty. Operand 90 states and 92 transitions. [2018-11-23 12:11:42,095 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 87 [2018-11-23 12:11:42,095 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:11:42,095 INFO L402 BasicCegarLoop]: trace histogram [60, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:11:42,095 INFO L423 AbstractCegarLoop]: === Iteration 32 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:11:42,095 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:11:42,095 INFO L82 PathProgramCache]: Analyzing trace with hash 1871963785, now seen corresponding path program 29 times [2018-11-23 12:11:42,096 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:11:42,096 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:11:42,096 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:42,096 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:11:42,097 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:42,177 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:43,900 INFO L256 TraceCheckUtils]: 0: Hoare triple {15248#true} call ULTIMATE.init(); {15248#true} is VALID [2018-11-23 12:11:43,900 INFO L273 TraceCheckUtils]: 1: Hoare triple {15248#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {15248#true} is VALID [2018-11-23 12:11:43,900 INFO L273 TraceCheckUtils]: 2: Hoare triple {15248#true} assume true; {15248#true} is VALID [2018-11-23 12:11:43,900 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {15248#true} {15248#true} #60#return; {15248#true} is VALID [2018-11-23 12:11:43,900 INFO L256 TraceCheckUtils]: 4: Hoare triple {15248#true} call #t~ret4 := main(); {15248#true} is VALID [2018-11-23 12:11:43,901 INFO L273 TraceCheckUtils]: 5: Hoare triple {15248#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {15250#(= main_~i~0 0)} is VALID [2018-11-23 12:11:43,902 INFO L273 TraceCheckUtils]: 6: Hoare triple {15250#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15251#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:43,903 INFO L273 TraceCheckUtils]: 7: Hoare triple {15251#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15252#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:43,904 INFO L273 TraceCheckUtils]: 8: Hoare triple {15252#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15253#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:43,905 INFO L273 TraceCheckUtils]: 9: Hoare triple {15253#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15254#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:43,906 INFO L273 TraceCheckUtils]: 10: Hoare triple {15254#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15255#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:43,907 INFO L273 TraceCheckUtils]: 11: Hoare triple {15255#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15256#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:43,908 INFO L273 TraceCheckUtils]: 12: Hoare triple {15256#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15257#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:43,908 INFO L273 TraceCheckUtils]: 13: Hoare triple {15257#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15258#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:43,909 INFO L273 TraceCheckUtils]: 14: Hoare triple {15258#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15259#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:43,910 INFO L273 TraceCheckUtils]: 15: Hoare triple {15259#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15260#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:43,911 INFO L273 TraceCheckUtils]: 16: Hoare triple {15260#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15261#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:43,912 INFO L273 TraceCheckUtils]: 17: Hoare triple {15261#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15262#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:43,913 INFO L273 TraceCheckUtils]: 18: Hoare triple {15262#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15263#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:43,914 INFO L273 TraceCheckUtils]: 19: Hoare triple {15263#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15264#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:43,915 INFO L273 TraceCheckUtils]: 20: Hoare triple {15264#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15265#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:43,916 INFO L273 TraceCheckUtils]: 21: Hoare triple {15265#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15266#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:43,917 INFO L273 TraceCheckUtils]: 22: Hoare triple {15266#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15267#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:43,918 INFO L273 TraceCheckUtils]: 23: Hoare triple {15267#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15268#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:43,919 INFO L273 TraceCheckUtils]: 24: Hoare triple {15268#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15269#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:43,920 INFO L273 TraceCheckUtils]: 25: Hoare triple {15269#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15270#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:43,921 INFO L273 TraceCheckUtils]: 26: Hoare triple {15270#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15271#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:43,922 INFO L273 TraceCheckUtils]: 27: Hoare triple {15271#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15272#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:43,923 INFO L273 TraceCheckUtils]: 28: Hoare triple {15272#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15273#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:43,924 INFO L273 TraceCheckUtils]: 29: Hoare triple {15273#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15274#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:43,925 INFO L273 TraceCheckUtils]: 30: Hoare triple {15274#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15275#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:43,925 INFO L273 TraceCheckUtils]: 31: Hoare triple {15275#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15276#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:43,926 INFO L273 TraceCheckUtils]: 32: Hoare triple {15276#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15277#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:43,927 INFO L273 TraceCheckUtils]: 33: Hoare triple {15277#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15278#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:43,928 INFO L273 TraceCheckUtils]: 34: Hoare triple {15278#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15279#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:43,931 INFO L273 TraceCheckUtils]: 35: Hoare triple {15279#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15280#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:43,932 INFO L273 TraceCheckUtils]: 36: Hoare triple {15280#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15281#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:43,933 INFO L273 TraceCheckUtils]: 37: Hoare triple {15281#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15282#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:43,933 INFO L273 TraceCheckUtils]: 38: Hoare triple {15282#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15283#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:43,934 INFO L273 TraceCheckUtils]: 39: Hoare triple {15283#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15284#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:43,935 INFO L273 TraceCheckUtils]: 40: Hoare triple {15284#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15285#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:43,936 INFO L273 TraceCheckUtils]: 41: Hoare triple {15285#(<= main_~i~0 35)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15286#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:43,937 INFO L273 TraceCheckUtils]: 42: Hoare triple {15286#(<= main_~i~0 36)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15287#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:43,938 INFO L273 TraceCheckUtils]: 43: Hoare triple {15287#(<= main_~i~0 37)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15288#(<= main_~i~0 38)} is VALID [2018-11-23 12:11:43,939 INFO L273 TraceCheckUtils]: 44: Hoare triple {15288#(<= main_~i~0 38)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15289#(<= main_~i~0 39)} is VALID [2018-11-23 12:11:43,940 INFO L273 TraceCheckUtils]: 45: Hoare triple {15289#(<= main_~i~0 39)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15290#(<= main_~i~0 40)} is VALID [2018-11-23 12:11:43,941 INFO L273 TraceCheckUtils]: 46: Hoare triple {15290#(<= main_~i~0 40)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15291#(<= main_~i~0 41)} is VALID [2018-11-23 12:11:43,942 INFO L273 TraceCheckUtils]: 47: Hoare triple {15291#(<= main_~i~0 41)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15292#(<= main_~i~0 42)} is VALID [2018-11-23 12:11:43,943 INFO L273 TraceCheckUtils]: 48: Hoare triple {15292#(<= main_~i~0 42)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15293#(<= main_~i~0 43)} is VALID [2018-11-23 12:11:43,944 INFO L273 TraceCheckUtils]: 49: Hoare triple {15293#(<= main_~i~0 43)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15294#(<= main_~i~0 44)} is VALID [2018-11-23 12:11:43,945 INFO L273 TraceCheckUtils]: 50: Hoare triple {15294#(<= main_~i~0 44)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15295#(<= main_~i~0 45)} is VALID [2018-11-23 12:11:43,946 INFO L273 TraceCheckUtils]: 51: Hoare triple {15295#(<= main_~i~0 45)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15296#(<= main_~i~0 46)} is VALID [2018-11-23 12:11:43,947 INFO L273 TraceCheckUtils]: 52: Hoare triple {15296#(<= main_~i~0 46)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15297#(<= main_~i~0 47)} is VALID [2018-11-23 12:11:43,947 INFO L273 TraceCheckUtils]: 53: Hoare triple {15297#(<= main_~i~0 47)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15298#(<= main_~i~0 48)} is VALID [2018-11-23 12:11:43,948 INFO L273 TraceCheckUtils]: 54: Hoare triple {15298#(<= main_~i~0 48)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15299#(<= main_~i~0 49)} is VALID [2018-11-23 12:11:43,949 INFO L273 TraceCheckUtils]: 55: Hoare triple {15299#(<= main_~i~0 49)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15300#(<= main_~i~0 50)} is VALID [2018-11-23 12:11:43,950 INFO L273 TraceCheckUtils]: 56: Hoare triple {15300#(<= main_~i~0 50)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15301#(<= main_~i~0 51)} is VALID [2018-11-23 12:11:43,951 INFO L273 TraceCheckUtils]: 57: Hoare triple {15301#(<= main_~i~0 51)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15302#(<= main_~i~0 52)} is VALID [2018-11-23 12:11:43,952 INFO L273 TraceCheckUtils]: 58: Hoare triple {15302#(<= main_~i~0 52)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15303#(<= main_~i~0 53)} is VALID [2018-11-23 12:11:43,953 INFO L273 TraceCheckUtils]: 59: Hoare triple {15303#(<= main_~i~0 53)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15304#(<= main_~i~0 54)} is VALID [2018-11-23 12:11:43,954 INFO L273 TraceCheckUtils]: 60: Hoare triple {15304#(<= main_~i~0 54)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15305#(<= main_~i~0 55)} is VALID [2018-11-23 12:11:43,955 INFO L273 TraceCheckUtils]: 61: Hoare triple {15305#(<= main_~i~0 55)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15306#(<= main_~i~0 56)} is VALID [2018-11-23 12:11:43,956 INFO L273 TraceCheckUtils]: 62: Hoare triple {15306#(<= main_~i~0 56)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15307#(<= main_~i~0 57)} is VALID [2018-11-23 12:11:43,957 INFO L273 TraceCheckUtils]: 63: Hoare triple {15307#(<= main_~i~0 57)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15308#(<= main_~i~0 58)} is VALID [2018-11-23 12:11:43,958 INFO L273 TraceCheckUtils]: 64: Hoare triple {15308#(<= main_~i~0 58)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15309#(<= main_~i~0 59)} is VALID [2018-11-23 12:11:43,959 INFO L273 TraceCheckUtils]: 65: Hoare triple {15309#(<= main_~i~0 59)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15310#(<= main_~i~0 60)} is VALID [2018-11-23 12:11:43,960 INFO L273 TraceCheckUtils]: 66: Hoare triple {15310#(<= main_~i~0 60)} assume !(~i~0 < 100000); {15249#false} is VALID [2018-11-23 12:11:43,960 INFO L273 TraceCheckUtils]: 67: Hoare triple {15249#false} ~i~0 := 1; {15249#false} is VALID [2018-11-23 12:11:43,960 INFO L273 TraceCheckUtils]: 68: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:11:43,960 INFO L273 TraceCheckUtils]: 69: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:11:43,961 INFO L273 TraceCheckUtils]: 70: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:11:43,961 INFO L273 TraceCheckUtils]: 71: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:11:43,961 INFO L273 TraceCheckUtils]: 72: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:11:43,961 INFO L273 TraceCheckUtils]: 73: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:11:43,962 INFO L273 TraceCheckUtils]: 74: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:11:43,962 INFO L273 TraceCheckUtils]: 75: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:11:43,962 INFO L273 TraceCheckUtils]: 76: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:11:43,962 INFO L273 TraceCheckUtils]: 77: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:11:43,963 INFO L273 TraceCheckUtils]: 78: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:11:43,963 INFO L273 TraceCheckUtils]: 79: Hoare triple {15249#false} assume !(~i~0 < 100000); {15249#false} is VALID [2018-11-23 12:11:43,963 INFO L273 TraceCheckUtils]: 80: Hoare triple {15249#false} ~i~0 := 1;~j~0 := 0; {15249#false} is VALID [2018-11-23 12:11:43,964 INFO L273 TraceCheckUtils]: 81: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {15249#false} is VALID [2018-11-23 12:11:43,964 INFO L256 TraceCheckUtils]: 82: Hoare triple {15249#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {15249#false} is VALID [2018-11-23 12:11:43,964 INFO L273 TraceCheckUtils]: 83: Hoare triple {15249#false} ~cond := #in~cond; {15249#false} is VALID [2018-11-23 12:11:43,964 INFO L273 TraceCheckUtils]: 84: Hoare triple {15249#false} assume 0 == ~cond; {15249#false} is VALID [2018-11-23 12:11:43,964 INFO L273 TraceCheckUtils]: 85: Hoare triple {15249#false} assume !false; {15249#false} is VALID [2018-11-23 12:11:43,971 INFO L134 CoverageAnalysis]: Checked inductivity of 1896 backedges. 0 proven. 1830 refuted. 0 times theorem prover too weak. 66 trivial. 0 not checked. [2018-11-23 12:11:43,971 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:11:43,971 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 30 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 30 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:11:43,988 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:12:42,615 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 31 check-sat command(s) [2018-11-23 12:12:42,615 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:12:42,692 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:12:42,694 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:12:43,023 INFO L256 TraceCheckUtils]: 0: Hoare triple {15248#true} call ULTIMATE.init(); {15248#true} is VALID [2018-11-23 12:12:43,023 INFO L273 TraceCheckUtils]: 1: Hoare triple {15248#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {15248#true} is VALID [2018-11-23 12:12:43,024 INFO L273 TraceCheckUtils]: 2: Hoare triple {15248#true} assume true; {15248#true} is VALID [2018-11-23 12:12:43,024 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {15248#true} {15248#true} #60#return; {15248#true} is VALID [2018-11-23 12:12:43,024 INFO L256 TraceCheckUtils]: 4: Hoare triple {15248#true} call #t~ret4 := main(); {15248#true} is VALID [2018-11-23 12:12:43,025 INFO L273 TraceCheckUtils]: 5: Hoare triple {15248#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {15329#(<= main_~i~0 0)} is VALID [2018-11-23 12:12:43,025 INFO L273 TraceCheckUtils]: 6: Hoare triple {15329#(<= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15251#(<= main_~i~0 1)} is VALID [2018-11-23 12:12:43,026 INFO L273 TraceCheckUtils]: 7: Hoare triple {15251#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15252#(<= main_~i~0 2)} is VALID [2018-11-23 12:12:43,027 INFO L273 TraceCheckUtils]: 8: Hoare triple {15252#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15253#(<= main_~i~0 3)} is VALID [2018-11-23 12:12:43,028 INFO L273 TraceCheckUtils]: 9: Hoare triple {15253#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15254#(<= main_~i~0 4)} is VALID [2018-11-23 12:12:43,029 INFO L273 TraceCheckUtils]: 10: Hoare triple {15254#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15255#(<= main_~i~0 5)} is VALID [2018-11-23 12:12:43,029 INFO L273 TraceCheckUtils]: 11: Hoare triple {15255#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15256#(<= main_~i~0 6)} is VALID [2018-11-23 12:12:43,030 INFO L273 TraceCheckUtils]: 12: Hoare triple {15256#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15257#(<= main_~i~0 7)} is VALID [2018-11-23 12:12:43,031 INFO L273 TraceCheckUtils]: 13: Hoare triple {15257#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15258#(<= main_~i~0 8)} is VALID [2018-11-23 12:12:43,032 INFO L273 TraceCheckUtils]: 14: Hoare triple {15258#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15259#(<= main_~i~0 9)} is VALID [2018-11-23 12:12:43,033 INFO L273 TraceCheckUtils]: 15: Hoare triple {15259#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15260#(<= main_~i~0 10)} is VALID [2018-11-23 12:12:43,034 INFO L273 TraceCheckUtils]: 16: Hoare triple {15260#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15261#(<= main_~i~0 11)} is VALID [2018-11-23 12:12:43,035 INFO L273 TraceCheckUtils]: 17: Hoare triple {15261#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15262#(<= main_~i~0 12)} is VALID [2018-11-23 12:12:43,038 INFO L273 TraceCheckUtils]: 18: Hoare triple {15262#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15263#(<= main_~i~0 13)} is VALID [2018-11-23 12:12:43,039 INFO L273 TraceCheckUtils]: 19: Hoare triple {15263#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15264#(<= main_~i~0 14)} is VALID [2018-11-23 12:12:43,041 INFO L273 TraceCheckUtils]: 20: Hoare triple {15264#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15265#(<= main_~i~0 15)} is VALID [2018-11-23 12:12:43,042 INFO L273 TraceCheckUtils]: 21: Hoare triple {15265#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15266#(<= main_~i~0 16)} is VALID [2018-11-23 12:12:43,043 INFO L273 TraceCheckUtils]: 22: Hoare triple {15266#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15267#(<= main_~i~0 17)} is VALID [2018-11-23 12:12:43,044 INFO L273 TraceCheckUtils]: 23: Hoare triple {15267#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15268#(<= main_~i~0 18)} is VALID [2018-11-23 12:12:43,045 INFO L273 TraceCheckUtils]: 24: Hoare triple {15268#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15269#(<= main_~i~0 19)} is VALID [2018-11-23 12:12:43,048 INFO L273 TraceCheckUtils]: 25: Hoare triple {15269#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15270#(<= main_~i~0 20)} is VALID [2018-11-23 12:12:43,049 INFO L273 TraceCheckUtils]: 26: Hoare triple {15270#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15271#(<= main_~i~0 21)} is VALID [2018-11-23 12:12:43,049 INFO L273 TraceCheckUtils]: 27: Hoare triple {15271#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15272#(<= main_~i~0 22)} is VALID [2018-11-23 12:12:43,050 INFO L273 TraceCheckUtils]: 28: Hoare triple {15272#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15273#(<= main_~i~0 23)} is VALID [2018-11-23 12:12:43,051 INFO L273 TraceCheckUtils]: 29: Hoare triple {15273#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15274#(<= main_~i~0 24)} is VALID [2018-11-23 12:12:43,051 INFO L273 TraceCheckUtils]: 30: Hoare triple {15274#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15275#(<= main_~i~0 25)} is VALID [2018-11-23 12:12:43,052 INFO L273 TraceCheckUtils]: 31: Hoare triple {15275#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15276#(<= main_~i~0 26)} is VALID [2018-11-23 12:12:43,052 INFO L273 TraceCheckUtils]: 32: Hoare triple {15276#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15277#(<= main_~i~0 27)} is VALID [2018-11-23 12:12:43,053 INFO L273 TraceCheckUtils]: 33: Hoare triple {15277#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15278#(<= main_~i~0 28)} is VALID [2018-11-23 12:12:43,054 INFO L273 TraceCheckUtils]: 34: Hoare triple {15278#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15279#(<= main_~i~0 29)} is VALID [2018-11-23 12:12:43,055 INFO L273 TraceCheckUtils]: 35: Hoare triple {15279#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15280#(<= main_~i~0 30)} is VALID [2018-11-23 12:12:43,056 INFO L273 TraceCheckUtils]: 36: Hoare triple {15280#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15281#(<= main_~i~0 31)} is VALID [2018-11-23 12:12:43,057 INFO L273 TraceCheckUtils]: 37: Hoare triple {15281#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15282#(<= main_~i~0 32)} is VALID [2018-11-23 12:12:43,058 INFO L273 TraceCheckUtils]: 38: Hoare triple {15282#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15283#(<= main_~i~0 33)} is VALID [2018-11-23 12:12:43,059 INFO L273 TraceCheckUtils]: 39: Hoare triple {15283#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15284#(<= main_~i~0 34)} is VALID [2018-11-23 12:12:43,060 INFO L273 TraceCheckUtils]: 40: Hoare triple {15284#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15285#(<= main_~i~0 35)} is VALID [2018-11-23 12:12:43,061 INFO L273 TraceCheckUtils]: 41: Hoare triple {15285#(<= main_~i~0 35)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15286#(<= main_~i~0 36)} is VALID [2018-11-23 12:12:43,062 INFO L273 TraceCheckUtils]: 42: Hoare triple {15286#(<= main_~i~0 36)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15287#(<= main_~i~0 37)} is VALID [2018-11-23 12:12:43,063 INFO L273 TraceCheckUtils]: 43: Hoare triple {15287#(<= main_~i~0 37)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15288#(<= main_~i~0 38)} is VALID [2018-11-23 12:12:43,064 INFO L273 TraceCheckUtils]: 44: Hoare triple {15288#(<= main_~i~0 38)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15289#(<= main_~i~0 39)} is VALID [2018-11-23 12:12:43,065 INFO L273 TraceCheckUtils]: 45: Hoare triple {15289#(<= main_~i~0 39)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15290#(<= main_~i~0 40)} is VALID [2018-11-23 12:12:43,066 INFO L273 TraceCheckUtils]: 46: Hoare triple {15290#(<= main_~i~0 40)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15291#(<= main_~i~0 41)} is VALID [2018-11-23 12:12:43,067 INFO L273 TraceCheckUtils]: 47: Hoare triple {15291#(<= main_~i~0 41)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15292#(<= main_~i~0 42)} is VALID [2018-11-23 12:12:43,068 INFO L273 TraceCheckUtils]: 48: Hoare triple {15292#(<= main_~i~0 42)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15293#(<= main_~i~0 43)} is VALID [2018-11-23 12:12:43,068 INFO L273 TraceCheckUtils]: 49: Hoare triple {15293#(<= main_~i~0 43)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15294#(<= main_~i~0 44)} is VALID [2018-11-23 12:12:43,069 INFO L273 TraceCheckUtils]: 50: Hoare triple {15294#(<= main_~i~0 44)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15295#(<= main_~i~0 45)} is VALID [2018-11-23 12:12:43,070 INFO L273 TraceCheckUtils]: 51: Hoare triple {15295#(<= main_~i~0 45)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15296#(<= main_~i~0 46)} is VALID [2018-11-23 12:12:43,071 INFO L273 TraceCheckUtils]: 52: Hoare triple {15296#(<= main_~i~0 46)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15297#(<= main_~i~0 47)} is VALID [2018-11-23 12:12:43,072 INFO L273 TraceCheckUtils]: 53: Hoare triple {15297#(<= main_~i~0 47)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15298#(<= main_~i~0 48)} is VALID [2018-11-23 12:12:43,073 INFO L273 TraceCheckUtils]: 54: Hoare triple {15298#(<= main_~i~0 48)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15299#(<= main_~i~0 49)} is VALID [2018-11-23 12:12:43,074 INFO L273 TraceCheckUtils]: 55: Hoare triple {15299#(<= main_~i~0 49)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15300#(<= main_~i~0 50)} is VALID [2018-11-23 12:12:43,075 INFO L273 TraceCheckUtils]: 56: Hoare triple {15300#(<= main_~i~0 50)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15301#(<= main_~i~0 51)} is VALID [2018-11-23 12:12:43,076 INFO L273 TraceCheckUtils]: 57: Hoare triple {15301#(<= main_~i~0 51)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15302#(<= main_~i~0 52)} is VALID [2018-11-23 12:12:43,077 INFO L273 TraceCheckUtils]: 58: Hoare triple {15302#(<= main_~i~0 52)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15303#(<= main_~i~0 53)} is VALID [2018-11-23 12:12:43,078 INFO L273 TraceCheckUtils]: 59: Hoare triple {15303#(<= main_~i~0 53)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15304#(<= main_~i~0 54)} is VALID [2018-11-23 12:12:43,079 INFO L273 TraceCheckUtils]: 60: Hoare triple {15304#(<= main_~i~0 54)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15305#(<= main_~i~0 55)} is VALID [2018-11-23 12:12:43,080 INFO L273 TraceCheckUtils]: 61: Hoare triple {15305#(<= main_~i~0 55)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15306#(<= main_~i~0 56)} is VALID [2018-11-23 12:12:43,081 INFO L273 TraceCheckUtils]: 62: Hoare triple {15306#(<= main_~i~0 56)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15307#(<= main_~i~0 57)} is VALID [2018-11-23 12:12:43,082 INFO L273 TraceCheckUtils]: 63: Hoare triple {15307#(<= main_~i~0 57)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15308#(<= main_~i~0 58)} is VALID [2018-11-23 12:12:43,083 INFO L273 TraceCheckUtils]: 64: Hoare triple {15308#(<= main_~i~0 58)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15309#(<= main_~i~0 59)} is VALID [2018-11-23 12:12:43,084 INFO L273 TraceCheckUtils]: 65: Hoare triple {15309#(<= main_~i~0 59)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {15310#(<= main_~i~0 60)} is VALID [2018-11-23 12:12:43,084 INFO L273 TraceCheckUtils]: 66: Hoare triple {15310#(<= main_~i~0 60)} assume !(~i~0 < 100000); {15249#false} is VALID [2018-11-23 12:12:43,084 INFO L273 TraceCheckUtils]: 67: Hoare triple {15249#false} ~i~0 := 1; {15249#false} is VALID [2018-11-23 12:12:43,085 INFO L273 TraceCheckUtils]: 68: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:12:43,085 INFO L273 TraceCheckUtils]: 69: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:12:43,085 INFO L273 TraceCheckUtils]: 70: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:12:43,085 INFO L273 TraceCheckUtils]: 71: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:12:43,085 INFO L273 TraceCheckUtils]: 72: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:12:43,086 INFO L273 TraceCheckUtils]: 73: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:12:43,086 INFO L273 TraceCheckUtils]: 74: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:12:43,086 INFO L273 TraceCheckUtils]: 75: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:12:43,086 INFO L273 TraceCheckUtils]: 76: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:12:43,086 INFO L273 TraceCheckUtils]: 77: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:12:43,087 INFO L273 TraceCheckUtils]: 78: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {15249#false} is VALID [2018-11-23 12:12:43,087 INFO L273 TraceCheckUtils]: 79: Hoare triple {15249#false} assume !(~i~0 < 100000); {15249#false} is VALID [2018-11-23 12:12:43,087 INFO L273 TraceCheckUtils]: 80: Hoare triple {15249#false} ~i~0 := 1;~j~0 := 0; {15249#false} is VALID [2018-11-23 12:12:43,087 INFO L273 TraceCheckUtils]: 81: Hoare triple {15249#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {15249#false} is VALID [2018-11-23 12:12:43,087 INFO L256 TraceCheckUtils]: 82: Hoare triple {15249#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {15249#false} is VALID [2018-11-23 12:12:43,087 INFO L273 TraceCheckUtils]: 83: Hoare triple {15249#false} ~cond := #in~cond; {15249#false} is VALID [2018-11-23 12:12:43,088 INFO L273 TraceCheckUtils]: 84: Hoare triple {15249#false} assume 0 == ~cond; {15249#false} is VALID [2018-11-23 12:12:43,088 INFO L273 TraceCheckUtils]: 85: Hoare triple {15249#false} assume !false; {15249#false} is VALID [2018-11-23 12:12:43,093 INFO L134 CoverageAnalysis]: Checked inductivity of 1896 backedges. 0 proven. 1830 refuted. 0 times theorem prover too weak. 66 trivial. 0 not checked. [2018-11-23 12:12:43,122 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:12:43,122 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [63, 63] total 64 [2018-11-23 12:12:43,123 INFO L78 Accepts]: Start accepts. Automaton has 64 states. Word has length 86 [2018-11-23 12:12:43,123 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:12:43,123 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 64 states. [2018-11-23 12:12:43,175 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 78 edges. 78 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:12:43,176 INFO L459 AbstractCegarLoop]: Interpolant automaton has 64 states [2018-11-23 12:12:43,176 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 64 interpolants. [2018-11-23 12:12:43,177 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=2016, Invalid=2016, Unknown=0, NotChecked=0, Total=4032 [2018-11-23 12:12:43,177 INFO L87 Difference]: Start difference. First operand 90 states and 92 transitions. Second operand 64 states. [2018-11-23 12:12:45,123 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:12:45,123 INFO L93 Difference]: Finished difference Result 135 states and 146 transitions. [2018-11-23 12:12:45,123 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 63 states. [2018-11-23 12:12:45,123 INFO L78 Accepts]: Start accepts. Automaton has 64 states. Word has length 86 [2018-11-23 12:12:45,123 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:12:45,123 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 64 states. [2018-11-23 12:12:45,125 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 63 states to 63 states and 131 transitions. [2018-11-23 12:12:45,125 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 64 states. [2018-11-23 12:12:45,127 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 63 states to 63 states and 131 transitions. [2018-11-23 12:12:45,127 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 63 states and 131 transitions. [2018-11-23 12:12:45,242 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 131 edges. 131 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:12:45,244 INFO L225 Difference]: With dead ends: 135 [2018-11-23 12:12:45,244 INFO L226 Difference]: Without dead ends: 112 [2018-11-23 12:12:45,245 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 148 GetRequests, 86 SyntacticMatches, 0 SemanticMatches, 62 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 118 ImplicationChecksByTransitivity, 1.4s TimeCoverageRelationStatistics Valid=2016, Invalid=2016, Unknown=0, NotChecked=0, Total=4032 [2018-11-23 12:12:45,246 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 112 states. [2018-11-23 12:12:45,321 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 112 to 91. [2018-11-23 12:12:45,322 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:12:45,322 INFO L82 GeneralOperation]: Start isEquivalent. First operand 112 states. Second operand 91 states. [2018-11-23 12:12:45,322 INFO L74 IsIncluded]: Start isIncluded. First operand 112 states. Second operand 91 states. [2018-11-23 12:12:45,322 INFO L87 Difference]: Start difference. First operand 112 states. Second operand 91 states. [2018-11-23 12:12:45,325 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:12:45,325 INFO L93 Difference]: Finished difference Result 112 states and 121 transitions. [2018-11-23 12:12:45,326 INFO L276 IsEmpty]: Start isEmpty. Operand 112 states and 121 transitions. [2018-11-23 12:12:45,326 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:12:45,326 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:12:45,326 INFO L74 IsIncluded]: Start isIncluded. First operand 91 states. Second operand 112 states. [2018-11-23 12:12:45,327 INFO L87 Difference]: Start difference. First operand 91 states. Second operand 112 states. [2018-11-23 12:12:45,329 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:12:45,329 INFO L93 Difference]: Finished difference Result 112 states and 121 transitions. [2018-11-23 12:12:45,329 INFO L276 IsEmpty]: Start isEmpty. Operand 112 states and 121 transitions. [2018-11-23 12:12:45,329 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:12:45,329 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:12:45,330 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:12:45,330 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:12:45,330 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 91 states. [2018-11-23 12:12:45,331 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 91 states to 91 states and 93 transitions. [2018-11-23 12:12:45,331 INFO L78 Accepts]: Start accepts. Automaton has 91 states and 93 transitions. Word has length 86 [2018-11-23 12:12:45,331 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:12:45,332 INFO L480 AbstractCegarLoop]: Abstraction has 91 states and 93 transitions. [2018-11-23 12:12:45,332 INFO L481 AbstractCegarLoop]: Interpolant automaton has 64 states. [2018-11-23 12:12:45,332 INFO L276 IsEmpty]: Start isEmpty. Operand 91 states and 93 transitions. [2018-11-23 12:12:45,332 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 88 [2018-11-23 12:12:45,332 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:12:45,333 INFO L402 BasicCegarLoop]: trace histogram [61, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:12:45,333 INFO L423 AbstractCegarLoop]: === Iteration 33 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:12:45,333 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:12:45,333 INFO L82 PathProgramCache]: Analyzing trace with hash 1964401125, now seen corresponding path program 30 times [2018-11-23 12:12:45,333 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:12:45,333 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:12:45,334 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:12:45,334 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:12:45,334 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:12:45,418 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:12:47,096 INFO L256 TraceCheckUtils]: 0: Hoare triple {16210#true} call ULTIMATE.init(); {16210#true} is VALID [2018-11-23 12:12:47,096 INFO L273 TraceCheckUtils]: 1: Hoare triple {16210#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {16210#true} is VALID [2018-11-23 12:12:47,096 INFO L273 TraceCheckUtils]: 2: Hoare triple {16210#true} assume true; {16210#true} is VALID [2018-11-23 12:12:47,096 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {16210#true} {16210#true} #60#return; {16210#true} is VALID [2018-11-23 12:12:47,097 INFO L256 TraceCheckUtils]: 4: Hoare triple {16210#true} call #t~ret4 := main(); {16210#true} is VALID [2018-11-23 12:12:47,097 INFO L273 TraceCheckUtils]: 5: Hoare triple {16210#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);~i~0 := 0;~j~0 := 0; {16212#(= main_~i~0 0)} is VALID [2018-11-23 12:12:47,099 INFO L273 TraceCheckUtils]: 6: Hoare triple {16212#(= main_~i~0 0)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16213#(<= main_~i~0 1)} is VALID [2018-11-23 12:12:47,099 INFO L273 TraceCheckUtils]: 7: Hoare triple {16213#(<= main_~i~0 1)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16214#(<= main_~i~0 2)} is VALID [2018-11-23 12:12:47,101 INFO L273 TraceCheckUtils]: 8: Hoare triple {16214#(<= main_~i~0 2)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16215#(<= main_~i~0 3)} is VALID [2018-11-23 12:12:47,102 INFO L273 TraceCheckUtils]: 9: Hoare triple {16215#(<= main_~i~0 3)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16216#(<= main_~i~0 4)} is VALID [2018-11-23 12:12:47,103 INFO L273 TraceCheckUtils]: 10: Hoare triple {16216#(<= main_~i~0 4)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16217#(<= main_~i~0 5)} is VALID [2018-11-23 12:12:47,104 INFO L273 TraceCheckUtils]: 11: Hoare triple {16217#(<= main_~i~0 5)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16218#(<= main_~i~0 6)} is VALID [2018-11-23 12:12:47,105 INFO L273 TraceCheckUtils]: 12: Hoare triple {16218#(<= main_~i~0 6)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16219#(<= main_~i~0 7)} is VALID [2018-11-23 12:12:47,106 INFO L273 TraceCheckUtils]: 13: Hoare triple {16219#(<= main_~i~0 7)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16220#(<= main_~i~0 8)} is VALID [2018-11-23 12:12:47,107 INFO L273 TraceCheckUtils]: 14: Hoare triple {16220#(<= main_~i~0 8)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16221#(<= main_~i~0 9)} is VALID [2018-11-23 12:12:47,109 INFO L273 TraceCheckUtils]: 15: Hoare triple {16221#(<= main_~i~0 9)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16222#(<= main_~i~0 10)} is VALID [2018-11-23 12:12:47,110 INFO L273 TraceCheckUtils]: 16: Hoare triple {16222#(<= main_~i~0 10)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16223#(<= main_~i~0 11)} is VALID [2018-11-23 12:12:47,112 INFO L273 TraceCheckUtils]: 17: Hoare triple {16223#(<= main_~i~0 11)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16224#(<= main_~i~0 12)} is VALID [2018-11-23 12:12:47,112 INFO L273 TraceCheckUtils]: 18: Hoare triple {16224#(<= main_~i~0 12)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16225#(<= main_~i~0 13)} is VALID [2018-11-23 12:12:47,113 INFO L273 TraceCheckUtils]: 19: Hoare triple {16225#(<= main_~i~0 13)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16226#(<= main_~i~0 14)} is VALID [2018-11-23 12:12:47,114 INFO L273 TraceCheckUtils]: 20: Hoare triple {16226#(<= main_~i~0 14)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16227#(<= main_~i~0 15)} is VALID [2018-11-23 12:12:47,119 INFO L273 TraceCheckUtils]: 21: Hoare triple {16227#(<= main_~i~0 15)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16228#(<= main_~i~0 16)} is VALID [2018-11-23 12:12:47,119 INFO L273 TraceCheckUtils]: 22: Hoare triple {16228#(<= main_~i~0 16)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16229#(<= main_~i~0 17)} is VALID [2018-11-23 12:12:47,122 INFO L273 TraceCheckUtils]: 23: Hoare triple {16229#(<= main_~i~0 17)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16230#(<= main_~i~0 18)} is VALID [2018-11-23 12:12:47,122 INFO L273 TraceCheckUtils]: 24: Hoare triple {16230#(<= main_~i~0 18)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16231#(<= main_~i~0 19)} is VALID [2018-11-23 12:12:47,124 INFO L273 TraceCheckUtils]: 25: Hoare triple {16231#(<= main_~i~0 19)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16232#(<= main_~i~0 20)} is VALID [2018-11-23 12:12:47,126 INFO L273 TraceCheckUtils]: 26: Hoare triple {16232#(<= main_~i~0 20)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16233#(<= main_~i~0 21)} is VALID [2018-11-23 12:12:47,127 INFO L273 TraceCheckUtils]: 27: Hoare triple {16233#(<= main_~i~0 21)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16234#(<= main_~i~0 22)} is VALID [2018-11-23 12:12:47,129 INFO L273 TraceCheckUtils]: 28: Hoare triple {16234#(<= main_~i~0 22)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16235#(<= main_~i~0 23)} is VALID [2018-11-23 12:12:47,129 INFO L273 TraceCheckUtils]: 29: Hoare triple {16235#(<= main_~i~0 23)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16236#(<= main_~i~0 24)} is VALID [2018-11-23 12:12:47,131 INFO L273 TraceCheckUtils]: 30: Hoare triple {16236#(<= main_~i~0 24)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16237#(<= main_~i~0 25)} is VALID [2018-11-23 12:12:47,131 INFO L273 TraceCheckUtils]: 31: Hoare triple {16237#(<= main_~i~0 25)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16238#(<= main_~i~0 26)} is VALID [2018-11-23 12:12:47,133 INFO L273 TraceCheckUtils]: 32: Hoare triple {16238#(<= main_~i~0 26)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16239#(<= main_~i~0 27)} is VALID [2018-11-23 12:12:47,134 INFO L273 TraceCheckUtils]: 33: Hoare triple {16239#(<= main_~i~0 27)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16240#(<= main_~i~0 28)} is VALID [2018-11-23 12:12:47,135 INFO L273 TraceCheckUtils]: 34: Hoare triple {16240#(<= main_~i~0 28)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16241#(<= main_~i~0 29)} is VALID [2018-11-23 12:12:47,136 INFO L273 TraceCheckUtils]: 35: Hoare triple {16241#(<= main_~i~0 29)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16242#(<= main_~i~0 30)} is VALID [2018-11-23 12:12:47,137 INFO L273 TraceCheckUtils]: 36: Hoare triple {16242#(<= main_~i~0 30)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16243#(<= main_~i~0 31)} is VALID [2018-11-23 12:12:47,138 INFO L273 TraceCheckUtils]: 37: Hoare triple {16243#(<= main_~i~0 31)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16244#(<= main_~i~0 32)} is VALID [2018-11-23 12:12:47,139 INFO L273 TraceCheckUtils]: 38: Hoare triple {16244#(<= main_~i~0 32)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16245#(<= main_~i~0 33)} is VALID [2018-11-23 12:12:47,141 INFO L273 TraceCheckUtils]: 39: Hoare triple {16245#(<= main_~i~0 33)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16246#(<= main_~i~0 34)} is VALID [2018-11-23 12:12:47,143 INFO L273 TraceCheckUtils]: 40: Hoare triple {16246#(<= main_~i~0 34)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16247#(<= main_~i~0 35)} is VALID [2018-11-23 12:12:47,144 INFO L273 TraceCheckUtils]: 41: Hoare triple {16247#(<= main_~i~0 35)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16248#(<= main_~i~0 36)} is VALID [2018-11-23 12:12:47,145 INFO L273 TraceCheckUtils]: 42: Hoare triple {16248#(<= main_~i~0 36)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16249#(<= main_~i~0 37)} is VALID [2018-11-23 12:12:47,145 INFO L273 TraceCheckUtils]: 43: Hoare triple {16249#(<= main_~i~0 37)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16250#(<= main_~i~0 38)} is VALID [2018-11-23 12:12:47,147 INFO L273 TraceCheckUtils]: 44: Hoare triple {16250#(<= main_~i~0 38)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16251#(<= main_~i~0 39)} is VALID [2018-11-23 12:12:47,148 INFO L273 TraceCheckUtils]: 45: Hoare triple {16251#(<= main_~i~0 39)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16252#(<= main_~i~0 40)} is VALID [2018-11-23 12:12:47,149 INFO L273 TraceCheckUtils]: 46: Hoare triple {16252#(<= main_~i~0 40)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16253#(<= main_~i~0 41)} is VALID [2018-11-23 12:12:47,150 INFO L273 TraceCheckUtils]: 47: Hoare triple {16253#(<= main_~i~0 41)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16254#(<= main_~i~0 42)} is VALID [2018-11-23 12:12:47,151 INFO L273 TraceCheckUtils]: 48: Hoare triple {16254#(<= main_~i~0 42)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16255#(<= main_~i~0 43)} is VALID [2018-11-23 12:12:47,152 INFO L273 TraceCheckUtils]: 49: Hoare triple {16255#(<= main_~i~0 43)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16256#(<= main_~i~0 44)} is VALID [2018-11-23 12:12:47,153 INFO L273 TraceCheckUtils]: 50: Hoare triple {16256#(<= main_~i~0 44)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16257#(<= main_~i~0 45)} is VALID [2018-11-23 12:12:47,154 INFO L273 TraceCheckUtils]: 51: Hoare triple {16257#(<= main_~i~0 45)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16258#(<= main_~i~0 46)} is VALID [2018-11-23 12:12:47,160 INFO L273 TraceCheckUtils]: 52: Hoare triple {16258#(<= main_~i~0 46)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16259#(<= main_~i~0 47)} is VALID [2018-11-23 12:12:47,161 INFO L273 TraceCheckUtils]: 53: Hoare triple {16259#(<= main_~i~0 47)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16260#(<= main_~i~0 48)} is VALID [2018-11-23 12:12:47,161 INFO L273 TraceCheckUtils]: 54: Hoare triple {16260#(<= main_~i~0 48)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16261#(<= main_~i~0 49)} is VALID [2018-11-23 12:12:47,162 INFO L273 TraceCheckUtils]: 55: Hoare triple {16261#(<= main_~i~0 49)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16262#(<= main_~i~0 50)} is VALID [2018-11-23 12:12:47,163 INFO L273 TraceCheckUtils]: 56: Hoare triple {16262#(<= main_~i~0 50)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16263#(<= main_~i~0 51)} is VALID [2018-11-23 12:12:47,163 INFO L273 TraceCheckUtils]: 57: Hoare triple {16263#(<= main_~i~0 51)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16264#(<= main_~i~0 52)} is VALID [2018-11-23 12:12:47,165 INFO L273 TraceCheckUtils]: 58: Hoare triple {16264#(<= main_~i~0 52)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16265#(<= main_~i~0 53)} is VALID [2018-11-23 12:12:47,165 INFO L273 TraceCheckUtils]: 59: Hoare triple {16265#(<= main_~i~0 53)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16266#(<= main_~i~0 54)} is VALID [2018-11-23 12:12:47,167 INFO L273 TraceCheckUtils]: 60: Hoare triple {16266#(<= main_~i~0 54)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16267#(<= main_~i~0 55)} is VALID [2018-11-23 12:12:47,168 INFO L273 TraceCheckUtils]: 61: Hoare triple {16267#(<= main_~i~0 55)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16268#(<= main_~i~0 56)} is VALID [2018-11-23 12:12:47,169 INFO L273 TraceCheckUtils]: 62: Hoare triple {16268#(<= main_~i~0 56)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16269#(<= main_~i~0 57)} is VALID [2018-11-23 12:12:47,170 INFO L273 TraceCheckUtils]: 63: Hoare triple {16269#(<= main_~i~0 57)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16270#(<= main_~i~0 58)} is VALID [2018-11-23 12:12:47,171 INFO L273 TraceCheckUtils]: 64: Hoare triple {16270#(<= main_~i~0 58)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16271#(<= main_~i~0 59)} is VALID [2018-11-23 12:12:47,172 INFO L273 TraceCheckUtils]: 65: Hoare triple {16271#(<= main_~i~0 59)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16272#(<= main_~i~0 60)} is VALID [2018-11-23 12:12:47,173 INFO L273 TraceCheckUtils]: 66: Hoare triple {16272#(<= main_~i~0 60)} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {16273#(<= main_~i~0 61)} is VALID [2018-11-23 12:12:47,173 INFO L273 TraceCheckUtils]: 67: Hoare triple {16273#(<= main_~i~0 61)} assume !(~i~0 < 100000); {16211#false} is VALID [2018-11-23 12:12:47,174 INFO L273 TraceCheckUtils]: 68: Hoare triple {16211#false} ~i~0 := 1; {16211#false} is VALID [2018-11-23 12:12:47,174 INFO L273 TraceCheckUtils]: 69: Hoare triple {16211#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {16211#false} is VALID [2018-11-23 12:12:47,174 INFO L273 TraceCheckUtils]: 70: Hoare triple {16211#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {16211#false} is VALID [2018-11-23 12:12:47,174 INFO L273 TraceCheckUtils]: 71: Hoare triple {16211#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {16211#false} is VALID [2018-11-23 12:12:47,174 INFO L273 TraceCheckUtils]: 72: Hoare triple {16211#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {16211#false} is VALID [2018-11-23 12:12:47,175 INFO L273 TraceCheckUtils]: 73: Hoare triple {16211#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {16211#false} is VALID [2018-11-23 12:12:47,175 INFO L273 TraceCheckUtils]: 74: Hoare triple {16211#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {16211#false} is VALID [2018-11-23 12:12:47,175 INFO L273 TraceCheckUtils]: 75: Hoare triple {16211#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {16211#false} is VALID [2018-11-23 12:12:47,175 INFO L273 TraceCheckUtils]: 76: Hoare triple {16211#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {16211#false} is VALID [2018-11-23 12:12:47,175 INFO L273 TraceCheckUtils]: 77: Hoare triple {16211#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {16211#false} is VALID [2018-11-23 12:12:47,176 INFO L273 TraceCheckUtils]: 78: Hoare triple {16211#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {16211#false} is VALID [2018-11-23 12:12:47,176 INFO L273 TraceCheckUtils]: 79: Hoare triple {16211#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 9 + ~i~0;~j~0 := 1 + ~j~0; {16211#false} is VALID [2018-11-23 12:12:47,176 INFO L273 TraceCheckUtils]: 80: Hoare triple {16211#false} assume !(~i~0 < 100000); {16211#false} is VALID [2018-11-23 12:12:47,176 INFO L273 TraceCheckUtils]: 81: Hoare triple {16211#false} ~i~0 := 1;~j~0 := 0; {16211#false} is VALID [2018-11-23 12:12:47,176 INFO L273 TraceCheckUtils]: 82: Hoare triple {16211#false} assume !!(~i~0 < 100000);call #t~mem2 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);call #t~mem3 := read~int(~#b~0.base, ~#b~0.offset + 4 * (1 + 9 * ~j~0), 4); {16211#false} is VALID [2018-11-23 12:12:47,177 INFO L256 TraceCheckUtils]: 83: Hoare triple {16211#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {16211#false} is VALID [2018-11-23 12:12:47,177 INFO L273 TraceCheckUtils]: 84: Hoare triple {16211#false} ~cond := #in~cond; {16211#false} is VALID [2018-11-23 12:12:47,177 INFO L273 TraceCheckUtils]: 85: Hoare triple {16211#false} assume 0 == ~cond; {16211#false} is VALID [2018-11-23 12:12:47,177 INFO L273 TraceCheckUtils]: 86: Hoare triple {16211#false} assume !false; {16211#false} is VALID [2018-11-23 12:12:47,183 INFO L134 CoverageAnalysis]: Checked inductivity of 1957 backedges. 0 proven. 1891 refuted. 0 times theorem prover too weak. 66 trivial. 0 not checked. [2018-11-23 12:12:47,183 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:12:47,183 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 31 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 31 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:12:47,196 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE