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_07_true-unreach-call.i -------------------------------------------------------------------------------- This is Ultimate 0.1.23-61f4311 [2018-11-23 12:08:46,766 INFO L170 SettingsManager]: Resetting all preferences to default values... [2018-11-23 12:08:46,770 INFO L174 SettingsManager]: Resetting UltimateCore preferences to default values [2018-11-23 12:08:46,783 INFO L177 SettingsManager]: Ultimate Commandline Interface provides no preferences, ignoring... [2018-11-23 12:08:46,784 INFO L174 SettingsManager]: Resetting Boogie Preprocessor preferences to default values [2018-11-23 12:08:46,785 INFO L174 SettingsManager]: Resetting Boogie Procedure Inliner preferences to default values [2018-11-23 12:08:46,786 INFO L174 SettingsManager]: Resetting Abstract Interpretation preferences to default values [2018-11-23 12:08:46,788 INFO L174 SettingsManager]: Resetting LassoRanker preferences to default values [2018-11-23 12:08:46,789 INFO L174 SettingsManager]: Resetting Reaching Definitions preferences to default values [2018-11-23 12:08:46,790 INFO L174 SettingsManager]: Resetting SyntaxChecker preferences to default values [2018-11-23 12:08:46,791 INFO L177 SettingsManager]: Büchi Program Product provides no preferences, ignoring... [2018-11-23 12:08:46,791 INFO L174 SettingsManager]: Resetting LTL2Aut preferences to default values [2018-11-23 12:08:46,792 INFO L174 SettingsManager]: Resetting PEA to Boogie preferences to default values [2018-11-23 12:08:46,793 INFO L174 SettingsManager]: Resetting BlockEncodingV2 preferences to default values [2018-11-23 12:08:46,794 INFO L174 SettingsManager]: Resetting ChcToBoogie preferences to default values [2018-11-23 12:08:46,795 INFO L174 SettingsManager]: Resetting AutomataScriptInterpreter preferences to default values [2018-11-23 12:08:46,796 INFO L174 SettingsManager]: Resetting BuchiAutomizer preferences to default values [2018-11-23 12:08:46,798 INFO L174 SettingsManager]: Resetting CACSL2BoogieTranslator preferences to default values [2018-11-23 12:08:46,800 INFO L174 SettingsManager]: Resetting CodeCheck preferences to default values [2018-11-23 12:08:46,801 INFO L174 SettingsManager]: Resetting InvariantSynthesis preferences to default values [2018-11-23 12:08:46,802 INFO L174 SettingsManager]: Resetting RCFGBuilder preferences to default values [2018-11-23 12:08:46,804 INFO L174 SettingsManager]: Resetting TraceAbstraction preferences to default values [2018-11-23 12:08:46,806 INFO L177 SettingsManager]: TraceAbstractionConcurrent provides no preferences, ignoring... [2018-11-23 12:08:46,807 INFO L177 SettingsManager]: TraceAbstractionWithAFAs provides no preferences, ignoring... [2018-11-23 12:08:46,807 INFO L174 SettingsManager]: Resetting TreeAutomizer preferences to default values [2018-11-23 12:08:46,808 INFO L174 SettingsManager]: Resetting IcfgTransformer preferences to default values [2018-11-23 12:08:46,809 INFO L174 SettingsManager]: Resetting Boogie Printer preferences to default values [2018-11-23 12:08:46,810 INFO L174 SettingsManager]: Resetting ReqPrinter preferences to default values [2018-11-23 12:08:46,811 INFO L174 SettingsManager]: Resetting Witness Printer preferences to default values [2018-11-23 12:08:46,812 INFO L177 SettingsManager]: Boogie PL CUP Parser provides no preferences, ignoring... [2018-11-23 12:08:46,812 INFO L174 SettingsManager]: Resetting CDTParser preferences to default values [2018-11-23 12:08:46,813 INFO L177 SettingsManager]: AutomataScriptParser provides no preferences, ignoring... [2018-11-23 12:08:46,813 INFO L177 SettingsManager]: ReqParser provides no preferences, ignoring... [2018-11-23 12:08:46,813 INFO L174 SettingsManager]: Resetting SmtParser preferences to default values [2018-11-23 12:08:46,814 INFO L174 SettingsManager]: Resetting Witness Parser preferences to default values [2018-11-23 12:08:46,815 INFO L181 SettingsManager]: Finished resetting all preferences to default values... [2018-11-23 12:08:46,816 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:08:46,840 INFO L110 SettingsManager]: Loading preferences was successful [2018-11-23 12:08:46,841 INFO L112 SettingsManager]: Preferences different from defaults after loading the file: [2018-11-23 12:08:46,842 INFO L131 SettingsManager]: Preferences of Boogie Procedure Inliner differ from their defaults: [2018-11-23 12:08:46,842 INFO L133 SettingsManager]: * ... calls to implemented procedures=ONLY_FOR_CONCURRENT_PROGRAMS [2018-11-23 12:08:46,842 INFO L131 SettingsManager]: Preferences of BlockEncodingV2 differ from their defaults: [2018-11-23 12:08:46,843 INFO L133 SettingsManager]: * Create parallel compositions if possible=false [2018-11-23 12:08:46,843 INFO L133 SettingsManager]: * Use SBE=true [2018-11-23 12:08:46,843 INFO L131 SettingsManager]: Preferences of CACSL2BoogieTranslator differ from their defaults: [2018-11-23 12:08:46,843 INFO L133 SettingsManager]: * sizeof long=4 [2018-11-23 12:08:46,843 INFO L133 SettingsManager]: * Overapproximate operations on floating types=true [2018-11-23 12:08:46,844 INFO L133 SettingsManager]: * sizeof POINTER=4 [2018-11-23 12:08:46,844 INFO L133 SettingsManager]: * Check division by zero=IGNORE [2018-11-23 12:08:46,844 INFO L133 SettingsManager]: * Pointer to allocated memory at dereference=IGNORE [2018-11-23 12:08:46,844 INFO L133 SettingsManager]: * If two pointers are subtracted or compared they have the same base address=IGNORE [2018-11-23 12:08:46,844 INFO L133 SettingsManager]: * Check array bounds for arrays that are off heap=IGNORE [2018-11-23 12:08:46,845 INFO L133 SettingsManager]: * sizeof long double=12 [2018-11-23 12:08:46,845 INFO L133 SettingsManager]: * Check if freed pointer was valid=false [2018-11-23 12:08:46,845 INFO L133 SettingsManager]: * Use constant arrays=true [2018-11-23 12:08:46,845 INFO L133 SettingsManager]: * Pointer base address is valid at dereference=IGNORE [2018-11-23 12:08:46,845 INFO L131 SettingsManager]: Preferences of RCFGBuilder differ from their defaults: [2018-11-23 12:08:46,846 INFO L133 SettingsManager]: * Size of a code block=SequenceOfStatements [2018-11-23 12:08:46,846 INFO L133 SettingsManager]: * To the following directory=./dump/ [2018-11-23 12:08:46,846 INFO L133 SettingsManager]: * SMT solver=External_DefaultMode [2018-11-23 12:08:46,846 INFO L133 SettingsManager]: * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in -t:2000 [2018-11-23 12:08:46,846 INFO L131 SettingsManager]: Preferences of TraceAbstraction differ from their defaults: [2018-11-23 12:08:46,847 INFO L133 SettingsManager]: * Compute Interpolants along a Counterexample=FPandBP [2018-11-23 12:08:46,847 INFO L133 SettingsManager]: * Positions where we compute the Hoare Annotation=LoopsAndPotentialCycles [2018-11-23 12:08:46,847 INFO L133 SettingsManager]: * Trace refinement strategy=CAMEL [2018-11-23 12:08:46,847 INFO L133 SettingsManager]: * SMT solver=External_ModelsAndUnsatCoreMode [2018-11-23 12:08:46,847 INFO L133 SettingsManager]: * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in [2018-11-23 12:08:46,848 INFO L133 SettingsManager]: * Compute Hoare Annotation of negated interpolant automaton, abstraction and CFG=true [2018-11-23 12:08:46,890 INFO L81 nceAwareModelManager]: Repository-Root is: /tmp [2018-11-23 12:08:46,908 INFO L258 ainManager$Toolchain]: [Toolchain 1]: Applicable parser(s) successfully (re)initialized [2018-11-23 12:08:46,913 INFO L214 ainManager$Toolchain]: [Toolchain 1]: Toolchain selected. [2018-11-23 12:08:46,915 INFO L271 PluginConnector]: Initializing CDTParser... [2018-11-23 12:08:46,915 INFO L276 PluginConnector]: CDTParser initialized [2018-11-23 12:08:46,916 INFO L418 ainManager$Toolchain]: [Toolchain 1]: Parsing single file: /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/../../../trunk/examples/svcomp/array-examples/standard_two_index_07_true-unreach-call.i [2018-11-23 12:08:46,979 INFO L221 CDTParser]: Created temporary CDT project at /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/ddd1ea2d3/a9eb73c660554943b2df596533b134f7/FLAGae3568363 [2018-11-23 12:08:47,401 INFO L307 CDTParser]: Found 1 translation units. [2018-11-23 12:08:47,402 INFO L161 CDTParser]: Scanning /storage/repos/ultimate/trunk/examples/svcomp/array-examples/standard_two_index_07_true-unreach-call.i [2018-11-23 12:08:47,408 INFO L355 CDTParser]: About to delete temporary CDT project at /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/ddd1ea2d3/a9eb73c660554943b2df596533b134f7/FLAGae3568363 [2018-11-23 12:08:47,802 INFO L363 CDTParser]: Successfully deleted /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/ddd1ea2d3/a9eb73c660554943b2df596533b134f7 [2018-11-23 12:08:47,812 INFO L296 ainManager$Toolchain]: ####################### [Toolchain 1] ####################### [2018-11-23 12:08:47,814 INFO L131 ToolchainWalker]: Walking toolchain with 6 elements. [2018-11-23 12:08:47,815 INFO L113 PluginConnector]: ------------------------CACSL2BoogieTranslator---------------------------- [2018-11-23 12:08:47,815 INFO L271 PluginConnector]: Initializing CACSL2BoogieTranslator... [2018-11-23 12:08:47,819 INFO L276 PluginConnector]: CACSL2BoogieTranslator initialized [2018-11-23 12:08:47,820 INFO L185 PluginConnector]: Executing the observer ACSLObjectContainerObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 23.11 12:08:47" (1/1) ... [2018-11-23 12:08:47,824 INFO L205 PluginConnector]: Invalid model from CACSL2BoogieTranslator for observer de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator.ACSLObjectContainerObserver@4da586e2 and model type de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:08:47, skipping insertion in model container [2018-11-23 12:08:47,824 INFO L185 PluginConnector]: Executing the observer CACSL2BoogieTranslatorObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 23.11 12:08:47" (1/1) ... [2018-11-23 12:08:47,834 INFO L145 MainTranslator]: Starting translation in SV-COMP mode [2018-11-23 12:08:47,860 INFO L176 MainTranslator]: Built tables and reachable declarations [2018-11-23 12:08:48,089 INFO L201 PostProcessor]: Analyzing one entry point: main [2018-11-23 12:08:48,094 INFO L191 MainTranslator]: Completed pre-run [2018-11-23 12:08:48,126 INFO L201 PostProcessor]: Analyzing one entry point: main [2018-11-23 12:08:48,157 INFO L195 MainTranslator]: Completed translation [2018-11-23 12:08:48,157 INFO L202 PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:08:48 WrapperNode [2018-11-23 12:08:48,158 INFO L132 PluginConnector]: ------------------------ END CACSL2BoogieTranslator---------------------------- [2018-11-23 12:08:48,158 INFO L113 PluginConnector]: ------------------------Boogie Procedure Inliner---------------------------- [2018-11-23 12:08:48,159 INFO L271 PluginConnector]: Initializing Boogie Procedure Inliner... [2018-11-23 12:08:48,159 INFO L276 PluginConnector]: Boogie Procedure Inliner initialized [2018-11-23 12:08:48,166 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:08:48" (1/1) ... [2018-11-23 12:08:48,173 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:08:48" (1/1) ... [2018-11-23 12:08:48,179 INFO L132 PluginConnector]: ------------------------ END Boogie Procedure Inliner---------------------------- [2018-11-23 12:08:48,180 INFO L113 PluginConnector]: ------------------------Boogie Preprocessor---------------------------- [2018-11-23 12:08:48,180 INFO L271 PluginConnector]: Initializing Boogie Preprocessor... [2018-11-23 12:08:48,180 INFO L276 PluginConnector]: Boogie Preprocessor initialized [2018-11-23 12:08:48,187 INFO L185 PluginConnector]: Executing the observer EnsureBoogieModelObserver from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:08:48" (1/1) ... [2018-11-23 12:08:48,187 INFO L185 PluginConnector]: Executing the observer TypeChecker from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:08:48" (1/1) ... [2018-11-23 12:08:48,189 INFO L185 PluginConnector]: Executing the observer ConstExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:08:48" (1/1) ... [2018-11-23 12:08:48,189 INFO L185 PluginConnector]: Executing the observer StructExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:08:48" (1/1) ... [2018-11-23 12:08:48,199 INFO L185 PluginConnector]: Executing the observer UnstructureCode from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:08:48" (1/1) ... [2018-11-23 12:08:48,205 INFO L185 PluginConnector]: Executing the observer FunctionInliner from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:08:48" (1/1) ... [2018-11-23 12:08:48,207 INFO L185 PluginConnector]: Executing the observer BoogieSymbolTableConstructor from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:08:48" (1/1) ... [2018-11-23 12:08:48,209 INFO L132 PluginConnector]: ------------------------ END Boogie Preprocessor---------------------------- [2018-11-23 12:08:48,209 INFO L113 PluginConnector]: ------------------------RCFGBuilder---------------------------- [2018-11-23 12:08:48,209 INFO L271 PluginConnector]: Initializing RCFGBuilder... [2018-11-23 12:08:48,210 INFO L276 PluginConnector]: RCFGBuilder initialized [2018-11-23 12:08:48,210 INFO L185 PluginConnector]: Executing the observer RCFGBuilderObserver from plugin RCFGBuilder for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:08:48" (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:08:48,324 INFO L130 BoogieDeclarations]: Found specification of procedure write~int [2018-11-23 12:08:48,325 INFO L130 BoogieDeclarations]: Found specification of procedure ULTIMATE.init [2018-11-23 12:08:48,325 INFO L138 BoogieDeclarations]: Found implementation of procedure ULTIMATE.init [2018-11-23 12:08:48,325 INFO L130 BoogieDeclarations]: Found specification of procedure #Ultimate.alloc [2018-11-23 12:08:48,325 INFO L130 BoogieDeclarations]: Found specification of procedure ULTIMATE.start [2018-11-23 12:08:48,325 INFO L138 BoogieDeclarations]: Found implementation of procedure ULTIMATE.start [2018-11-23 12:08:48,325 INFO L130 BoogieDeclarations]: Found specification of procedure read~int [2018-11-23 12:08:48,326 INFO L130 BoogieDeclarations]: Found specification of procedure main [2018-11-23 12:08:48,326 INFO L138 BoogieDeclarations]: Found implementation of procedure main [2018-11-23 12:08:48,326 INFO L130 BoogieDeclarations]: Found specification of procedure __VERIFIER_assert [2018-11-23 12:08:48,326 INFO L138 BoogieDeclarations]: Found implementation of procedure __VERIFIER_assert [2018-11-23 12:08:48,326 INFO L130 BoogieDeclarations]: Found specification of procedure ULTIMATE.dealloc [2018-11-23 12:08:48,856 INFO L275 CfgBuilder]: Using the 1 location(s) as analysis (start of procedure ULTIMATE.start) [2018-11-23 12:08:48,856 INFO L280 CfgBuilder]: Removed 3 assue(true) statements. [2018-11-23 12:08:48,857 INFO L202 PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 23.11 12:08:48 BoogieIcfgContainer [2018-11-23 12:08:48,857 INFO L132 PluginConnector]: ------------------------ END RCFGBuilder---------------------------- [2018-11-23 12:08:48,858 INFO L113 PluginConnector]: ------------------------TraceAbstraction---------------------------- [2018-11-23 12:08:48,859 INFO L271 PluginConnector]: Initializing TraceAbstraction... [2018-11-23 12:08:48,862 INFO L276 PluginConnector]: TraceAbstraction initialized [2018-11-23 12:08:48,862 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "CDTParser AST 23.11 12:08:47" (1/3) ... [2018-11-23 12:08:48,863 INFO L205 PluginConnector]: Invalid model from TraceAbstraction for observer de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionObserver@3d936c15 and model type de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction AST 23.11 12:08:48, skipping insertion in model container [2018-11-23 12:08:48,863 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:08:48" (2/3) ... [2018-11-23 12:08:48,864 INFO L205 PluginConnector]: Invalid model from TraceAbstraction for observer de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionObserver@3d936c15 and model type de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction AST 23.11 12:08:48, skipping insertion in model container [2018-11-23 12:08:48,864 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 23.11 12:08:48" (3/3) ... [2018-11-23 12:08:48,866 INFO L112 eAbstractionObserver]: Analyzing ICFG standard_two_index_07_true-unreach-call.i [2018-11-23 12:08:48,876 INFO L156 ceAbstractionStarter]: Automizer settings: Hoare:true NWA Interpolation:FPandBP Determinization: PREDICATE_ABSTRACTION [2018-11-23 12:08:48,885 INFO L168 ceAbstractionStarter]: Appying trace abstraction to program that has 1 error locations. [2018-11-23 12:08:48,903 INFO L257 AbstractCegarLoop]: Starting to check reachability of 1 error locations. [2018-11-23 12:08:48,937 INFO L133 ementStrategyFactory]: Using default assertion order modulation [2018-11-23 12:08:48,938 INFO L382 AbstractCegarLoop]: Interprodecural is true [2018-11-23 12:08:48,938 INFO L383 AbstractCegarLoop]: Hoare is true [2018-11-23 12:08:48,938 INFO L384 AbstractCegarLoop]: Compute interpolants for FPandBP [2018-11-23 12:08:48,939 INFO L385 AbstractCegarLoop]: Backedges is STRAIGHT_LINE [2018-11-23 12:08:48,939 INFO L386 AbstractCegarLoop]: Determinization is PREDICATE_ABSTRACTION [2018-11-23 12:08:48,939 INFO L387 AbstractCegarLoop]: Difference is false [2018-11-23 12:08:48,939 INFO L388 AbstractCegarLoop]: Minimize is MINIMIZE_SEVPA [2018-11-23 12:08:48,940 INFO L393 AbstractCegarLoop]: ======== Iteration 0==of CEGAR loop == AllErrorsAtOnce======== [2018-11-23 12:08:48,959 INFO L276 IsEmpty]: Start isEmpty. Operand 24 states. [2018-11-23 12:08:48,966 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 16 [2018-11-23 12:08:48,966 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:08:48,967 INFO L402 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:08:48,970 INFO L423 AbstractCegarLoop]: === Iteration 1 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:08:48,977 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:08:48,977 INFO L82 PathProgramCache]: Analyzing trace with hash -2029643862, now seen corresponding path program 1 times [2018-11-23 12:08:48,979 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:08:48,980 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:08:49,033 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:49,034 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:08:49,034 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:49,069 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:49,137 INFO L256 TraceCheckUtils]: 0: Hoare triple {27#true} call ULTIMATE.init(); {27#true} is VALID [2018-11-23 12:08:49,142 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:08:49,143 INFO L273 TraceCheckUtils]: 2: Hoare triple {27#true} assume true; {27#true} is VALID [2018-11-23 12:08:49,143 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {27#true} {27#true} #60#return; {27#true} is VALID [2018-11-23 12:08:49,144 INFO L256 TraceCheckUtils]: 4: Hoare triple {27#true} call #t~ret4 := main(); {27#true} is VALID [2018-11-23 12:08:49,144 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:08:49,145 INFO L273 TraceCheckUtils]: 6: Hoare triple {27#true} assume !true; {28#false} is VALID [2018-11-23 12:08:49,146 INFO L273 TraceCheckUtils]: 7: Hoare triple {28#false} ~i~0 := 1; {28#false} is VALID [2018-11-23 12:08:49,146 INFO L273 TraceCheckUtils]: 8: Hoare triple {28#false} assume !(~i~0 < 100000); {28#false} is VALID [2018-11-23 12:08:49,146 INFO L273 TraceCheckUtils]: 9: Hoare triple {28#false} ~i~0 := 1;~j~0 := 0; {28#false} is VALID [2018-11-23 12:08:49,146 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 + 7 * ~j~0), 4); {28#false} is VALID [2018-11-23 12:08:49,147 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:08:49,147 INFO L273 TraceCheckUtils]: 12: Hoare triple {28#false} ~cond := #in~cond; {28#false} is VALID [2018-11-23 12:08:49,148 INFO L273 TraceCheckUtils]: 13: Hoare triple {28#false} assume 0 == ~cond; {28#false} is VALID [2018-11-23 12:08:49,148 INFO L273 TraceCheckUtils]: 14: Hoare triple {28#false} assume !false; {28#false} is VALID [2018-11-23 12:08:49,151 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:08:49,154 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 12:08:49,154 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [2] imperfect sequences [] total 2 [2018-11-23 12:08:49,160 INFO L78 Accepts]: Start accepts. Automaton has 2 states. Word has length 15 [2018-11-23 12:08:49,163 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:08:49,167 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 2 states. [2018-11-23 12:08:49,249 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:08:49,249 INFO L459 AbstractCegarLoop]: Interpolant automaton has 2 states [2018-11-23 12:08:49,257 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 2 interpolants. [2018-11-23 12:08:49,257 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1, Invalid=1, Unknown=0, NotChecked=0, Total=2 [2018-11-23 12:08:49,260 INFO L87 Difference]: Start difference. First operand 24 states. Second operand 2 states. [2018-11-23 12:08:49,471 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:49,472 INFO L93 Difference]: Finished difference Result 41 states and 52 transitions. [2018-11-23 12:08:49,472 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 2 states. [2018-11-23 12:08:49,472 INFO L78 Accepts]: Start accepts. Automaton has 2 states. Word has length 15 [2018-11-23 12:08:49,473 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:08:49,474 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 2 states. [2018-11-23 12:08:49,484 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 2 states to 2 states and 52 transitions. [2018-11-23 12:08:49,485 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 2 states. [2018-11-23 12:08:49,489 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 2 states to 2 states and 52 transitions. [2018-11-23 12:08:49,490 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 2 states and 52 transitions. [2018-11-23 12:08:49,775 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:08:49,785 INFO L225 Difference]: With dead ends: 41 [2018-11-23 12:08:49,786 INFO L226 Difference]: Without dead ends: 19 [2018-11-23 12:08:49,789 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:08:49,806 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 19 states. [2018-11-23 12:08:49,835 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 19 to 19. [2018-11-23 12:08:49,835 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:08:49,836 INFO L82 GeneralOperation]: Start isEquivalent. First operand 19 states. Second operand 19 states. [2018-11-23 12:08:49,836 INFO L74 IsIncluded]: Start isIncluded. First operand 19 states. Second operand 19 states. [2018-11-23 12:08:49,836 INFO L87 Difference]: Start difference. First operand 19 states. Second operand 19 states. [2018-11-23 12:08:49,839 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:49,839 INFO L93 Difference]: Finished difference Result 19 states and 21 transitions. [2018-11-23 12:08:49,840 INFO L276 IsEmpty]: Start isEmpty. Operand 19 states and 21 transitions. [2018-11-23 12:08:49,840 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:49,840 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:49,840 INFO L74 IsIncluded]: Start isIncluded. First operand 19 states. Second operand 19 states. [2018-11-23 12:08:49,841 INFO L87 Difference]: Start difference. First operand 19 states. Second operand 19 states. [2018-11-23 12:08:49,844 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:49,844 INFO L93 Difference]: Finished difference Result 19 states and 21 transitions. [2018-11-23 12:08:49,844 INFO L276 IsEmpty]: Start isEmpty. Operand 19 states and 21 transitions. [2018-11-23 12:08:49,845 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:49,845 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:49,845 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:08:49,845 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:08:49,846 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 19 states. [2018-11-23 12:08:49,847 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 19 states to 19 states and 21 transitions. [2018-11-23 12:08:49,849 INFO L78 Accepts]: Start accepts. Automaton has 19 states and 21 transitions. Word has length 15 [2018-11-23 12:08:49,849 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:08:49,849 INFO L480 AbstractCegarLoop]: Abstraction has 19 states and 21 transitions. [2018-11-23 12:08:49,850 INFO L481 AbstractCegarLoop]: Interpolant automaton has 2 states. [2018-11-23 12:08:49,850 INFO L276 IsEmpty]: Start isEmpty. Operand 19 states and 21 transitions. [2018-11-23 12:08:49,850 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 16 [2018-11-23 12:08:49,851 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:08:49,851 INFO L402 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:08:49,851 INFO L423 AbstractCegarLoop]: === Iteration 2 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:08:49,851 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:08:49,851 INFO L82 PathProgramCache]: Analyzing trace with hash 905206694, now seen corresponding path program 1 times [2018-11-23 12:08:49,852 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:08:49,852 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:08:49,853 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:49,853 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:08:49,853 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:49,873 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:49,963 INFO L256 TraceCheckUtils]: 0: Hoare triple {151#true} call ULTIMATE.init(); {151#true} is VALID [2018-11-23 12:08:49,964 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:08:49,964 INFO L273 TraceCheckUtils]: 2: Hoare triple {151#true} assume true; {151#true} is VALID [2018-11-23 12:08:49,964 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {151#true} {151#true} #60#return; {151#true} is VALID [2018-11-23 12:08:49,965 INFO L256 TraceCheckUtils]: 4: Hoare triple {151#true} call #t~ret4 := main(); {151#true} is VALID [2018-11-23 12:08:49,966 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:08:49,969 INFO L273 TraceCheckUtils]: 6: Hoare triple {153#(= main_~i~0 0)} assume !(~i~0 < 100000); {152#false} is VALID [2018-11-23 12:08:49,969 INFO L273 TraceCheckUtils]: 7: Hoare triple {152#false} ~i~0 := 1; {152#false} is VALID [2018-11-23 12:08:49,969 INFO L273 TraceCheckUtils]: 8: Hoare triple {152#false} assume !(~i~0 < 100000); {152#false} is VALID [2018-11-23 12:08:49,970 INFO L273 TraceCheckUtils]: 9: Hoare triple {152#false} ~i~0 := 1;~j~0 := 0; {152#false} is VALID [2018-11-23 12:08:49,970 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 + 7 * ~j~0), 4); {152#false} is VALID [2018-11-23 12:08:49,970 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:08:49,971 INFO L273 TraceCheckUtils]: 12: Hoare triple {152#false} ~cond := #in~cond; {152#false} is VALID [2018-11-23 12:08:49,971 INFO L273 TraceCheckUtils]: 13: Hoare triple {152#false} assume 0 == ~cond; {152#false} is VALID [2018-11-23 12:08:49,971 INFO L273 TraceCheckUtils]: 14: Hoare triple {152#false} assume !false; {152#false} is VALID [2018-11-23 12:08:49,973 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:08:49,973 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 12:08:49,973 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [3] imperfect sequences [] total 3 [2018-11-23 12:08:49,975 INFO L78 Accepts]: Start accepts. Automaton has 3 states. Word has length 15 [2018-11-23 12:08:49,975 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:08:49,975 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 3 states. [2018-11-23 12:08:50,113 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:08:50,114 INFO L459 AbstractCegarLoop]: Interpolant automaton has 3 states [2018-11-23 12:08:50,114 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 3 interpolants. [2018-11-23 12:08:50,114 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=3, Invalid=3, Unknown=0, NotChecked=0, Total=6 [2018-11-23 12:08:50,114 INFO L87 Difference]: Start difference. First operand 19 states and 21 transitions. Second operand 3 states. [2018-11-23 12:08:50,244 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:50,244 INFO L93 Difference]: Finished difference Result 32 states and 36 transitions. [2018-11-23 12:08:50,245 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 3 states. [2018-11-23 12:08:50,245 INFO L78 Accepts]: Start accepts. Automaton has 3 states. Word has length 15 [2018-11-23 12:08:50,245 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:08:50,245 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 3 states. [2018-11-23 12:08:50,248 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 3 states to 3 states and 36 transitions. [2018-11-23 12:08:50,249 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 3 states. [2018-11-23 12:08:50,251 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 3 states to 3 states and 36 transitions. [2018-11-23 12:08:50,251 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 3 states and 36 transitions. [2018-11-23 12:08:50,320 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:08:50,321 INFO L225 Difference]: With dead ends: 32 [2018-11-23 12:08:50,322 INFO L226 Difference]: Without dead ends: 20 [2018-11-23 12:08:50,323 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:08:50,323 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 20 states. [2018-11-23 12:08:50,377 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 20 to 20. [2018-11-23 12:08:50,377 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:08:50,378 INFO L82 GeneralOperation]: Start isEquivalent. First operand 20 states. Second operand 20 states. [2018-11-23 12:08:50,378 INFO L74 IsIncluded]: Start isIncluded. First operand 20 states. Second operand 20 states. [2018-11-23 12:08:50,378 INFO L87 Difference]: Start difference. First operand 20 states. Second operand 20 states. [2018-11-23 12:08:50,380 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:50,380 INFO L93 Difference]: Finished difference Result 20 states and 22 transitions. [2018-11-23 12:08:50,380 INFO L276 IsEmpty]: Start isEmpty. Operand 20 states and 22 transitions. [2018-11-23 12:08:50,381 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:50,381 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:50,381 INFO L74 IsIncluded]: Start isIncluded. First operand 20 states. Second operand 20 states. [2018-11-23 12:08:50,381 INFO L87 Difference]: Start difference. First operand 20 states. Second operand 20 states. [2018-11-23 12:08:50,383 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:50,384 INFO L93 Difference]: Finished difference Result 20 states and 22 transitions. [2018-11-23 12:08:50,384 INFO L276 IsEmpty]: Start isEmpty. Operand 20 states and 22 transitions. [2018-11-23 12:08:50,384 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:50,385 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:50,385 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:08:50,385 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:08:50,385 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 20 states. [2018-11-23 12:08:50,387 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 20 states to 20 states and 22 transitions. [2018-11-23 12:08:50,387 INFO L78 Accepts]: Start accepts. Automaton has 20 states and 22 transitions. Word has length 15 [2018-11-23 12:08:50,387 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:08:50,387 INFO L480 AbstractCegarLoop]: Abstraction has 20 states and 22 transitions. [2018-11-23 12:08:50,388 INFO L481 AbstractCegarLoop]: Interpolant automaton has 3 states. [2018-11-23 12:08:50,388 INFO L276 IsEmpty]: Start isEmpty. Operand 20 states and 22 transitions. [2018-11-23 12:08:50,388 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 17 [2018-11-23 12:08:50,389 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:08:50,389 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:08:50,389 INFO L423 AbstractCegarLoop]: === Iteration 3 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:08:50,389 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:08:50,389 INFO L82 PathProgramCache]: Analyzing trace with hash -764882998, now seen corresponding path program 1 times [2018-11-23 12:08:50,390 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:08:50,390 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:08:50,391 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:50,391 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:08:50,391 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:50,419 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:50,548 INFO L256 TraceCheckUtils]: 0: Hoare triple {272#true} call ULTIMATE.init(); {272#true} is VALID [2018-11-23 12:08:50,549 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:08:50,549 INFO L273 TraceCheckUtils]: 2: Hoare triple {272#true} assume true; {272#true} is VALID [2018-11-23 12:08:50,549 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {272#true} {272#true} #60#return; {272#true} is VALID [2018-11-23 12:08:50,550 INFO L256 TraceCheckUtils]: 4: Hoare triple {272#true} call #t~ret4 := main(); {272#true} is VALID [2018-11-23 12:08:50,550 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:08:50,550 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:08:50,551 INFO L273 TraceCheckUtils]: 7: Hoare triple {272#true} assume !(~i~0 < 100000); {272#true} is VALID [2018-11-23 12:08:50,566 INFO L273 TraceCheckUtils]: 8: Hoare triple {272#true} ~i~0 := 1; {274#(= main_~i~0 1)} is VALID [2018-11-23 12:08:50,581 INFO L273 TraceCheckUtils]: 9: Hoare triple {274#(= main_~i~0 1)} assume !(~i~0 < 100000); {273#false} is VALID [2018-11-23 12:08:50,581 INFO L273 TraceCheckUtils]: 10: Hoare triple {273#false} ~i~0 := 1;~j~0 := 0; {273#false} is VALID [2018-11-23 12:08:50,582 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 + 7 * ~j~0), 4); {273#false} is VALID [2018-11-23 12:08:50,582 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:08:50,583 INFO L273 TraceCheckUtils]: 13: Hoare triple {273#false} ~cond := #in~cond; {273#false} is VALID [2018-11-23 12:08:50,583 INFO L273 TraceCheckUtils]: 14: Hoare triple {273#false} assume 0 == ~cond; {273#false} is VALID [2018-11-23 12:08:50,583 INFO L273 TraceCheckUtils]: 15: Hoare triple {273#false} assume !false; {273#false} is VALID [2018-11-23 12:08:50,585 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:08:50,585 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 12:08:50,585 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [3] imperfect sequences [] total 3 [2018-11-23 12:08:50,586 INFO L78 Accepts]: Start accepts. Automaton has 3 states. Word has length 16 [2018-11-23 12:08:50,586 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:08:50,586 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 3 states. [2018-11-23 12:08:50,786 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:08:50,786 INFO L459 AbstractCegarLoop]: Interpolant automaton has 3 states [2018-11-23 12:08:50,787 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 3 interpolants. [2018-11-23 12:08:50,787 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=3, Invalid=3, Unknown=0, NotChecked=0, Total=6 [2018-11-23 12:08:50,787 INFO L87 Difference]: Start difference. First operand 20 states and 22 transitions. Second operand 3 states. [2018-11-23 12:08:50,927 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:50,927 INFO L93 Difference]: Finished difference Result 34 states and 38 transitions. [2018-11-23 12:08:50,927 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 3 states. [2018-11-23 12:08:50,927 INFO L78 Accepts]: Start accepts. Automaton has 3 states. Word has length 16 [2018-11-23 12:08:50,928 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:08:50,928 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 3 states. [2018-11-23 12:08:50,931 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 3 states to 3 states and 37 transitions. [2018-11-23 12:08:50,931 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 3 states. [2018-11-23 12:08:50,933 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 3 states to 3 states and 37 transitions. [2018-11-23 12:08:50,933 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 3 states and 37 transitions. [2018-11-23 12:08:51,115 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:08:51,119 INFO L225 Difference]: With dead ends: 34 [2018-11-23 12:08:51,119 INFO L226 Difference]: Without dead ends: 24 [2018-11-23 12:08:51,119 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:08:51,120 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 24 states. [2018-11-23 12:08:51,172 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 24 to 21. [2018-11-23 12:08:51,172 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:08:51,172 INFO L82 GeneralOperation]: Start isEquivalent. First operand 24 states. Second operand 21 states. [2018-11-23 12:08:51,172 INFO L74 IsIncluded]: Start isIncluded. First operand 24 states. Second operand 21 states. [2018-11-23 12:08:51,173 INFO L87 Difference]: Start difference. First operand 24 states. Second operand 21 states. [2018-11-23 12:08:51,176 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:51,176 INFO L93 Difference]: Finished difference Result 24 states and 27 transitions. [2018-11-23 12:08:51,176 INFO L276 IsEmpty]: Start isEmpty. Operand 24 states and 27 transitions. [2018-11-23 12:08:51,177 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:51,177 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:51,177 INFO L74 IsIncluded]: Start isIncluded. First operand 21 states. Second operand 24 states. [2018-11-23 12:08:51,177 INFO L87 Difference]: Start difference. First operand 21 states. Second operand 24 states. [2018-11-23 12:08:51,180 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:51,180 INFO L93 Difference]: Finished difference Result 24 states and 27 transitions. [2018-11-23 12:08:51,180 INFO L276 IsEmpty]: Start isEmpty. Operand 24 states and 27 transitions. [2018-11-23 12:08:51,181 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:51,181 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:51,181 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:08:51,181 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:08:51,182 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 21 states. [2018-11-23 12:08:51,184 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 21 states to 21 states and 23 transitions. [2018-11-23 12:08:51,184 INFO L78 Accepts]: Start accepts. Automaton has 21 states and 23 transitions. Word has length 16 [2018-11-23 12:08:51,184 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:08:51,184 INFO L480 AbstractCegarLoop]: Abstraction has 21 states and 23 transitions. [2018-11-23 12:08:51,185 INFO L481 AbstractCegarLoop]: Interpolant automaton has 3 states. [2018-11-23 12:08:51,185 INFO L276 IsEmpty]: Start isEmpty. Operand 21 states and 23 transitions. [2018-11-23 12:08:51,186 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 18 [2018-11-23 12:08:51,186 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:08:51,186 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:08:51,187 INFO L423 AbstractCegarLoop]: === Iteration 4 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:08:51,187 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:08:51,187 INFO L82 PathProgramCache]: Analyzing trace with hash -59429947, now seen corresponding path program 1 times [2018-11-23 12:08:51,187 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:08:51,188 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:08:51,189 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:51,189 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:08:51,189 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:51,218 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:51,577 INFO L256 TraceCheckUtils]: 0: Hoare triple {407#true} call ULTIMATE.init(); {407#true} is VALID [2018-11-23 12:08:51,578 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:08:51,578 INFO L273 TraceCheckUtils]: 2: Hoare triple {407#true} assume true; {407#true} is VALID [2018-11-23 12:08:51,578 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {407#true} {407#true} #60#return; {407#true} is VALID [2018-11-23 12:08:51,579 INFO L256 TraceCheckUtils]: 4: Hoare triple {407#true} call #t~ret4 := main(); {407#true} is VALID [2018-11-23 12:08:51,582 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:08:51,583 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:08:51,584 INFO L273 TraceCheckUtils]: 7: Hoare triple {410#(<= main_~i~0 1)} assume !(~i~0 < 100000); {408#false} is VALID [2018-11-23 12:08:51,584 INFO L273 TraceCheckUtils]: 8: Hoare triple {408#false} ~i~0 := 1; {408#false} is VALID [2018-11-23 12:08:51,585 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {408#false} is VALID [2018-11-23 12:08:51,585 INFO L273 TraceCheckUtils]: 10: Hoare triple {408#false} assume !(~i~0 < 100000); {408#false} is VALID [2018-11-23 12:08:51,585 INFO L273 TraceCheckUtils]: 11: Hoare triple {408#false} ~i~0 := 1;~j~0 := 0; {408#false} is VALID [2018-11-23 12:08:51,586 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 + 7 * ~j~0), 4); {408#false} is VALID [2018-11-23 12:08:51,586 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:08:51,586 INFO L273 TraceCheckUtils]: 14: Hoare triple {408#false} ~cond := #in~cond; {408#false} is VALID [2018-11-23 12:08:51,586 INFO L273 TraceCheckUtils]: 15: Hoare triple {408#false} assume 0 == ~cond; {408#false} is VALID [2018-11-23 12:08:51,587 INFO L273 TraceCheckUtils]: 16: Hoare triple {408#false} assume !false; {408#false} is VALID [2018-11-23 12:08:51,588 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:08:51,588 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:08:51,588 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:08:51,605 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:08:51,627 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:51,653 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:51,657 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:08:51,956 INFO L256 TraceCheckUtils]: 0: Hoare triple {407#true} call ULTIMATE.init(); {407#true} is VALID [2018-11-23 12:08:51,956 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:08:51,957 INFO L273 TraceCheckUtils]: 2: Hoare triple {407#true} assume true; {407#true} is VALID [2018-11-23 12:08:51,957 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {407#true} {407#true} #60#return; {407#true} is VALID [2018-11-23 12:08:51,957 INFO L256 TraceCheckUtils]: 4: Hoare triple {407#true} call #t~ret4 := main(); {407#true} is VALID [2018-11-23 12:08:51,958 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:08:51,959 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:08:51,964 INFO L273 TraceCheckUtils]: 7: Hoare triple {410#(<= main_~i~0 1)} assume !(~i~0 < 100000); {408#false} is VALID [2018-11-23 12:08:51,964 INFO L273 TraceCheckUtils]: 8: Hoare triple {408#false} ~i~0 := 1; {408#false} is VALID [2018-11-23 12:08:51,965 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {408#false} is VALID [2018-11-23 12:08:51,965 INFO L273 TraceCheckUtils]: 10: Hoare triple {408#false} assume !(~i~0 < 100000); {408#false} is VALID [2018-11-23 12:08:51,965 INFO L273 TraceCheckUtils]: 11: Hoare triple {408#false} ~i~0 := 1;~j~0 := 0; {408#false} is VALID [2018-11-23 12:08:51,966 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 + 7 * ~j~0), 4); {408#false} is VALID [2018-11-23 12:08:51,966 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:08:51,966 INFO L273 TraceCheckUtils]: 14: Hoare triple {408#false} ~cond := #in~cond; {408#false} is VALID [2018-11-23 12:08:51,966 INFO L273 TraceCheckUtils]: 15: Hoare triple {408#false} assume 0 == ~cond; {408#false} is VALID [2018-11-23 12:08:51,967 INFO L273 TraceCheckUtils]: 16: Hoare triple {408#false} assume !false; {408#false} is VALID [2018-11-23 12:08:51,967 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:08:51,987 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:08:51,987 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [4, 4] total 5 [2018-11-23 12:08:51,988 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 17 [2018-11-23 12:08:51,988 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:08:51,988 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states. [2018-11-23 12:08:52,049 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:08:52,049 INFO L459 AbstractCegarLoop]: Interpolant automaton has 5 states [2018-11-23 12:08:52,049 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 5 interpolants. [2018-11-23 12:08:52,049 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=10, Invalid=10, Unknown=0, NotChecked=0, Total=20 [2018-11-23 12:08:52,050 INFO L87 Difference]: Start difference. First operand 21 states and 23 transitions. Second operand 5 states. [2018-11-23 12:08:52,331 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:52,332 INFO L93 Difference]: Finished difference Result 38 states and 43 transitions. [2018-11-23 12:08:52,332 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 4 states. [2018-11-23 12:08:52,332 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 17 [2018-11-23 12:08:52,333 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:08:52,333 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 12:08:52,336 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 4 states to 4 states and 42 transitions. [2018-11-23 12:08:52,336 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 12:08:52,339 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 4 states to 4 states and 42 transitions. [2018-11-23 12:08:52,339 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 4 states and 42 transitions. [2018-11-23 12:08:52,537 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:08:52,539 INFO L225 Difference]: With dead ends: 38 [2018-11-23 12:08:52,540 INFO L226 Difference]: Without dead ends: 25 [2018-11-23 12:08:52,540 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 20 GetRequests, 17 SyntacticMatches, 0 SemanticMatches, 3 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=10, Invalid=10, Unknown=0, NotChecked=0, Total=20 [2018-11-23 12:08:52,541 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 25 states. [2018-11-23 12:08:52,562 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 25 to 22. [2018-11-23 12:08:52,562 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:08:52,562 INFO L82 GeneralOperation]: Start isEquivalent. First operand 25 states. Second operand 22 states. [2018-11-23 12:08:52,562 INFO L74 IsIncluded]: Start isIncluded. First operand 25 states. Second operand 22 states. [2018-11-23 12:08:52,562 INFO L87 Difference]: Start difference. First operand 25 states. Second operand 22 states. [2018-11-23 12:08:52,565 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:52,566 INFO L93 Difference]: Finished difference Result 25 states and 28 transitions. [2018-11-23 12:08:52,566 INFO L276 IsEmpty]: Start isEmpty. Operand 25 states and 28 transitions. [2018-11-23 12:08:52,566 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:52,567 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:52,567 INFO L74 IsIncluded]: Start isIncluded. First operand 22 states. Second operand 25 states. [2018-11-23 12:08:52,567 INFO L87 Difference]: Start difference. First operand 22 states. Second operand 25 states. [2018-11-23 12:08:52,569 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:52,570 INFO L93 Difference]: Finished difference Result 25 states and 28 transitions. [2018-11-23 12:08:52,570 INFO L276 IsEmpty]: Start isEmpty. Operand 25 states and 28 transitions. [2018-11-23 12:08:52,571 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:52,571 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:52,571 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:08:52,571 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:08:52,571 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 22 states. [2018-11-23 12:08:52,573 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 22 states to 22 states and 24 transitions. [2018-11-23 12:08:52,573 INFO L78 Accepts]: Start accepts. Automaton has 22 states and 24 transitions. Word has length 17 [2018-11-23 12:08:52,573 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:08:52,574 INFO L480 AbstractCegarLoop]: Abstraction has 22 states and 24 transitions. [2018-11-23 12:08:52,574 INFO L481 AbstractCegarLoop]: Interpolant automaton has 5 states. [2018-11-23 12:08:52,574 INFO L276 IsEmpty]: Start isEmpty. Operand 22 states and 24 transitions. [2018-11-23 12:08:52,574 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 19 [2018-11-23 12:08:52,575 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:08:52,575 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:08:52,575 INFO L423 AbstractCegarLoop]: === Iteration 5 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:08:52,575 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:08:52,576 INFO L82 PathProgramCache]: Analyzing trace with hash 1302144745, now seen corresponding path program 2 times [2018-11-23 12:08:52,576 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:08:52,576 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:08:52,577 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:52,577 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:08:52,577 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:52,601 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:52,697 INFO L256 TraceCheckUtils]: 0: Hoare triple {603#true} call ULTIMATE.init(); {603#true} is VALID [2018-11-23 12:08:52,697 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:08:52,698 INFO L273 TraceCheckUtils]: 2: Hoare triple {603#true} assume true; {603#true} is VALID [2018-11-23 12:08:52,698 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {603#true} {603#true} #60#return; {603#true} is VALID [2018-11-23 12:08:52,699 INFO L256 TraceCheckUtils]: 4: Hoare triple {603#true} call #t~ret4 := main(); {603#true} is VALID [2018-11-23 12:08:52,702 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:08:52,704 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:08:52,706 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:08:52,707 INFO L273 TraceCheckUtils]: 8: Hoare triple {607#(<= main_~i~0 2)} assume !(~i~0 < 100000); {604#false} is VALID [2018-11-23 12:08:52,707 INFO L273 TraceCheckUtils]: 9: Hoare triple {604#false} ~i~0 := 1; {604#false} is VALID [2018-11-23 12:08:52,707 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {604#false} is VALID [2018-11-23 12:08:52,707 INFO L273 TraceCheckUtils]: 11: Hoare triple {604#false} assume !(~i~0 < 100000); {604#false} is VALID [2018-11-23 12:08:52,708 INFO L273 TraceCheckUtils]: 12: Hoare triple {604#false} ~i~0 := 1;~j~0 := 0; {604#false} is VALID [2018-11-23 12:08:52,708 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 + 7 * ~j~0), 4); {604#false} is VALID [2018-11-23 12:08:52,708 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:08:52,708 INFO L273 TraceCheckUtils]: 15: Hoare triple {604#false} ~cond := #in~cond; {604#false} is VALID [2018-11-23 12:08:52,709 INFO L273 TraceCheckUtils]: 16: Hoare triple {604#false} assume 0 == ~cond; {604#false} is VALID [2018-11-23 12:08:52,709 INFO L273 TraceCheckUtils]: 17: Hoare triple {604#false} assume !false; {604#false} is VALID [2018-11-23 12:08:52,710 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:08:52,710 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:08:52,710 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:08:52,719 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:08:52,767 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:08:52,767 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:08:52,789 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:52,790 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:08:52,921 INFO L256 TraceCheckUtils]: 0: Hoare triple {603#true} call ULTIMATE.init(); {603#true} is VALID [2018-11-23 12:08:52,921 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:08:52,921 INFO L273 TraceCheckUtils]: 2: Hoare triple {603#true} assume true; {603#true} is VALID [2018-11-23 12:08:52,922 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {603#true} {603#true} #60#return; {603#true} is VALID [2018-11-23 12:08:52,922 INFO L256 TraceCheckUtils]: 4: Hoare triple {603#true} call #t~ret4 := main(); {603#true} is VALID [2018-11-23 12:08:52,923 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:08:52,924 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:08:52,929 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:08:52,929 INFO L273 TraceCheckUtils]: 8: Hoare triple {607#(<= main_~i~0 2)} assume !(~i~0 < 100000); {604#false} is VALID [2018-11-23 12:08:52,930 INFO L273 TraceCheckUtils]: 9: Hoare triple {604#false} ~i~0 := 1; {604#false} is VALID [2018-11-23 12:08:52,930 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {604#false} is VALID [2018-11-23 12:08:52,930 INFO L273 TraceCheckUtils]: 11: Hoare triple {604#false} assume !(~i~0 < 100000); {604#false} is VALID [2018-11-23 12:08:52,930 INFO L273 TraceCheckUtils]: 12: Hoare triple {604#false} ~i~0 := 1;~j~0 := 0; {604#false} is VALID [2018-11-23 12:08:52,931 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 + 7 * ~j~0), 4); {604#false} is VALID [2018-11-23 12:08:52,931 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:08:52,931 INFO L273 TraceCheckUtils]: 15: Hoare triple {604#false} ~cond := #in~cond; {604#false} is VALID [2018-11-23 12:08:52,931 INFO L273 TraceCheckUtils]: 16: Hoare triple {604#false} assume 0 == ~cond; {604#false} is VALID [2018-11-23 12:08:52,932 INFO L273 TraceCheckUtils]: 17: Hoare triple {604#false} assume !false; {604#false} is VALID [2018-11-23 12:08:52,932 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:08:52,952 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:08:52,953 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [5, 5] total 6 [2018-11-23 12:08:52,953 INFO L78 Accepts]: Start accepts. Automaton has 6 states. Word has length 18 [2018-11-23 12:08:52,953 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:08:52,954 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 6 states. [2018-11-23 12:08:52,975 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:08:52,975 INFO L459 AbstractCegarLoop]: Interpolant automaton has 6 states [2018-11-23 12:08:52,976 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 6 interpolants. [2018-11-23 12:08:52,976 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=15, Invalid=15, Unknown=0, NotChecked=0, Total=30 [2018-11-23 12:08:52,977 INFO L87 Difference]: Start difference. First operand 22 states and 24 transitions. Second operand 6 states. [2018-11-23 12:08:53,166 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:53,167 INFO L93 Difference]: Finished difference Result 39 states and 44 transitions. [2018-11-23 12:08:53,167 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 5 states. [2018-11-23 12:08:53,168 INFO L78 Accepts]: Start accepts. Automaton has 6 states. Word has length 18 [2018-11-23 12:08:53,168 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:08:53,168 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 6 states. [2018-11-23 12:08:53,171 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 43 transitions. [2018-11-23 12:08:53,171 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 6 states. [2018-11-23 12:08:53,173 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 43 transitions. [2018-11-23 12:08:53,174 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states and 43 transitions. [2018-11-23 12:08:53,245 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:08:53,247 INFO L225 Difference]: With dead ends: 39 [2018-11-23 12:08:53,247 INFO L226 Difference]: Without dead ends: 26 [2018-11-23 12:08:53,248 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:08:53,248 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 26 states. [2018-11-23 12:08:53,268 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 26 to 23. [2018-11-23 12:08:53,268 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:08:53,268 INFO L82 GeneralOperation]: Start isEquivalent. First operand 26 states. Second operand 23 states. [2018-11-23 12:08:53,268 INFO L74 IsIncluded]: Start isIncluded. First operand 26 states. Second operand 23 states. [2018-11-23 12:08:53,269 INFO L87 Difference]: Start difference. First operand 26 states. Second operand 23 states. [2018-11-23 12:08:53,270 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:53,271 INFO L93 Difference]: Finished difference Result 26 states and 29 transitions. [2018-11-23 12:08:53,271 INFO L276 IsEmpty]: Start isEmpty. Operand 26 states and 29 transitions. [2018-11-23 12:08:53,271 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:53,272 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:53,272 INFO L74 IsIncluded]: Start isIncluded. First operand 23 states. Second operand 26 states. [2018-11-23 12:08:53,272 INFO L87 Difference]: Start difference. First operand 23 states. Second operand 26 states. [2018-11-23 12:08:53,274 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:53,274 INFO L93 Difference]: Finished difference Result 26 states and 29 transitions. [2018-11-23 12:08:53,275 INFO L276 IsEmpty]: Start isEmpty. Operand 26 states and 29 transitions. [2018-11-23 12:08:53,275 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:53,275 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:53,276 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:08:53,276 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:08:53,276 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 23 states. [2018-11-23 12:08:53,277 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 23 states to 23 states and 25 transitions. [2018-11-23 12:08:53,278 INFO L78 Accepts]: Start accepts. Automaton has 23 states and 25 transitions. Word has length 18 [2018-11-23 12:08:53,278 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:08:53,278 INFO L480 AbstractCegarLoop]: Abstraction has 23 states and 25 transitions. [2018-11-23 12:08:53,278 INFO L481 AbstractCegarLoop]: Interpolant automaton has 6 states. [2018-11-23 12:08:53,278 INFO L276 IsEmpty]: Start isEmpty. Operand 23 states and 25 transitions. [2018-11-23 12:08:53,279 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 20 [2018-11-23 12:08:53,279 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:08:53,279 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:08:53,279 INFO L423 AbstractCegarLoop]: === Iteration 6 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:08:53,280 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:08:53,280 INFO L82 PathProgramCache]: Analyzing trace with hash 561287237, now seen corresponding path program 3 times [2018-11-23 12:08:53,280 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:08:53,280 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:08:53,281 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:53,281 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:08:53,282 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:53,305 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:53,423 INFO L256 TraceCheckUtils]: 0: Hoare triple {809#true} call ULTIMATE.init(); {809#true} is VALID [2018-11-23 12:08:53,423 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:08:53,424 INFO L273 TraceCheckUtils]: 2: Hoare triple {809#true} assume true; {809#true} is VALID [2018-11-23 12:08:53,424 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {809#true} {809#true} #60#return; {809#true} is VALID [2018-11-23 12:08:53,425 INFO L256 TraceCheckUtils]: 4: Hoare triple {809#true} call #t~ret4 := main(); {809#true} is VALID [2018-11-23 12:08:53,441 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:08:53,447 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:08:53,452 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:08:53,453 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:08:53,454 INFO L273 TraceCheckUtils]: 9: Hoare triple {814#(<= main_~i~0 3)} assume !(~i~0 < 100000); {810#false} is VALID [2018-11-23 12:08:53,454 INFO L273 TraceCheckUtils]: 10: Hoare triple {810#false} ~i~0 := 1; {810#false} is VALID [2018-11-23 12:08:53,455 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {810#false} is VALID [2018-11-23 12:08:53,455 INFO L273 TraceCheckUtils]: 12: Hoare triple {810#false} assume !(~i~0 < 100000); {810#false} is VALID [2018-11-23 12:08:53,455 INFO L273 TraceCheckUtils]: 13: Hoare triple {810#false} ~i~0 := 1;~j~0 := 0; {810#false} is VALID [2018-11-23 12:08:53,455 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 + 7 * ~j~0), 4); {810#false} is VALID [2018-11-23 12:08:53,456 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:08:53,456 INFO L273 TraceCheckUtils]: 16: Hoare triple {810#false} ~cond := #in~cond; {810#false} is VALID [2018-11-23 12:08:53,456 INFO L273 TraceCheckUtils]: 17: Hoare triple {810#false} assume 0 == ~cond; {810#false} is VALID [2018-11-23 12:08:53,456 INFO L273 TraceCheckUtils]: 18: Hoare triple {810#false} assume !false; {810#false} is VALID [2018-11-23 12:08:53,457 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:08:53,458 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:08:53,458 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:08:53,467 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:08:53,488 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 2 check-sat command(s) [2018-11-23 12:08:53,488 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:08:53,499 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:53,500 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:08:53,561 INFO L256 TraceCheckUtils]: 0: Hoare triple {809#true} call ULTIMATE.init(); {809#true} is VALID [2018-11-23 12:08:53,562 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:08:53,562 INFO L273 TraceCheckUtils]: 2: Hoare triple {809#true} assume true; {809#true} is VALID [2018-11-23 12:08:53,562 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {809#true} {809#true} #60#return; {809#true} is VALID [2018-11-23 12:08:53,562 INFO L256 TraceCheckUtils]: 4: Hoare triple {809#true} call #t~ret4 := main(); {809#true} is VALID [2018-11-23 12:08:53,562 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:08:53,563 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:08:53,563 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:08:53,563 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:08:53,563 INFO L273 TraceCheckUtils]: 9: Hoare triple {809#true} assume !(~i~0 < 100000); {809#true} is VALID [2018-11-23 12:08:53,564 INFO L273 TraceCheckUtils]: 10: Hoare triple {809#true} ~i~0 := 1; {812#(<= main_~i~0 1)} is VALID [2018-11-23 12:08:53,565 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {851#(<= main_~i~0 8)} is VALID [2018-11-23 12:08:53,565 INFO L273 TraceCheckUtils]: 12: Hoare triple {851#(<= main_~i~0 8)} assume !(~i~0 < 100000); {810#false} is VALID [2018-11-23 12:08:53,565 INFO L273 TraceCheckUtils]: 13: Hoare triple {810#false} ~i~0 := 1;~j~0 := 0; {810#false} is VALID [2018-11-23 12:08:53,566 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 + 7 * ~j~0), 4); {810#false} is VALID [2018-11-23 12:08:53,566 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:08:53,566 INFO L273 TraceCheckUtils]: 16: Hoare triple {810#false} ~cond := #in~cond; {810#false} is VALID [2018-11-23 12:08:53,566 INFO L273 TraceCheckUtils]: 17: Hoare triple {810#false} assume 0 == ~cond; {810#false} is VALID [2018-11-23 12:08:53,566 INFO L273 TraceCheckUtils]: 18: Hoare triple {810#false} assume !false; {810#false} is VALID [2018-11-23 12:08:53,567 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:08:53,587 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:08:53,587 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [6, 4] total 7 [2018-11-23 12:08:53,588 INFO L78 Accepts]: Start accepts. Automaton has 7 states. Word has length 19 [2018-11-23 12:08:53,588 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:08:53,588 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 7 states. [2018-11-23 12:08:53,625 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:08:53,625 INFO L459 AbstractCegarLoop]: Interpolant automaton has 7 states [2018-11-23 12:08:53,625 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 7 interpolants. [2018-11-23 12:08:53,625 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=21, Invalid=21, Unknown=0, NotChecked=0, Total=42 [2018-11-23 12:08:53,626 INFO L87 Difference]: Start difference. First operand 23 states and 25 transitions. Second operand 7 states. [2018-11-23 12:08:53,820 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:53,820 INFO L93 Difference]: Finished difference Result 45 states and 53 transitions. [2018-11-23 12:08:53,820 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 7 states. [2018-11-23 12:08:53,821 INFO L78 Accepts]: Start accepts. Automaton has 7 states. Word has length 19 [2018-11-23 12:08:53,821 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:08:53,821 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 7 states. [2018-11-23 12:08:53,824 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 7 states to 7 states and 52 transitions. [2018-11-23 12:08:53,824 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 7 states. [2018-11-23 12:08:53,829 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 7 states to 7 states and 52 transitions. [2018-11-23 12:08:53,829 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 7 states and 52 transitions. [2018-11-23 12:08:53,989 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:08:53,991 INFO L225 Difference]: With dead ends: 45 [2018-11-23 12:08:53,991 INFO L226 Difference]: Without dead ends: 32 [2018-11-23 12:08:53,992 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:08:53,992 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 32 states. [2018-11-23 12:08:54,010 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 32 to 26. [2018-11-23 12:08:54,010 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:08:54,010 INFO L82 GeneralOperation]: Start isEquivalent. First operand 32 states. Second operand 26 states. [2018-11-23 12:08:54,011 INFO L74 IsIncluded]: Start isIncluded. First operand 32 states. Second operand 26 states. [2018-11-23 12:08:54,011 INFO L87 Difference]: Start difference. First operand 32 states. Second operand 26 states. [2018-11-23 12:08:54,013 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:54,013 INFO L93 Difference]: Finished difference Result 32 states and 36 transitions. [2018-11-23 12:08:54,013 INFO L276 IsEmpty]: Start isEmpty. Operand 32 states and 36 transitions. [2018-11-23 12:08:54,014 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:54,014 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:54,014 INFO L74 IsIncluded]: Start isIncluded. First operand 26 states. Second operand 32 states. [2018-11-23 12:08:54,015 INFO L87 Difference]: Start difference. First operand 26 states. Second operand 32 states. [2018-11-23 12:08:54,017 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:54,017 INFO L93 Difference]: Finished difference Result 32 states and 36 transitions. [2018-11-23 12:08:54,017 INFO L276 IsEmpty]: Start isEmpty. Operand 32 states and 36 transitions. [2018-11-23 12:08:54,018 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:54,018 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:54,018 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:08:54,018 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:08:54,018 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 26 states. [2018-11-23 12:08:54,020 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 26 states to 26 states and 28 transitions. [2018-11-23 12:08:54,020 INFO L78 Accepts]: Start accepts. Automaton has 26 states and 28 transitions. Word has length 19 [2018-11-23 12:08:54,020 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:08:54,020 INFO L480 AbstractCegarLoop]: Abstraction has 26 states and 28 transitions. [2018-11-23 12:08:54,021 INFO L481 AbstractCegarLoop]: Interpolant automaton has 7 states. [2018-11-23 12:08:54,021 INFO L276 IsEmpty]: Start isEmpty. Operand 26 states and 28 transitions. [2018-11-23 12:08:54,021 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 23 [2018-11-23 12:08:54,021 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:08:54,022 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:08:54,022 INFO L423 AbstractCegarLoop]: === Iteration 7 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:08:54,022 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:08:54,022 INFO L82 PathProgramCache]: Analyzing trace with hash 53593642, now seen corresponding path program 4 times [2018-11-23 12:08:54,023 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:08:54,023 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:08:54,024 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:54,024 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:08:54,024 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:54,042 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:54,166 INFO L256 TraceCheckUtils]: 0: Hoare triple {1048#true} call ULTIMATE.init(); {1048#true} is VALID [2018-11-23 12:08:54,167 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:08:54,167 INFO L273 TraceCheckUtils]: 2: Hoare triple {1048#true} assume true; {1048#true} is VALID [2018-11-23 12:08:54,167 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1048#true} {1048#true} #60#return; {1048#true} is VALID [2018-11-23 12:08:54,168 INFO L256 TraceCheckUtils]: 4: Hoare triple {1048#true} call #t~ret4 := main(); {1048#true} is VALID [2018-11-23 12:08:54,169 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:08:54,170 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:08:54,170 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:08:54,171 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:08:54,173 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:08:54,174 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:08:54,175 INFO L273 TraceCheckUtils]: 11: Hoare triple {1055#(<= main_~i~0 5)} assume !(~i~0 < 100000); {1049#false} is VALID [2018-11-23 12:08:54,175 INFO L273 TraceCheckUtils]: 12: Hoare triple {1049#false} ~i~0 := 1; {1049#false} is VALID [2018-11-23 12:08:54,176 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1049#false} is VALID [2018-11-23 12:08:54,176 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1049#false} is VALID [2018-11-23 12:08:54,176 INFO L273 TraceCheckUtils]: 15: Hoare triple {1049#false} assume !(~i~0 < 100000); {1049#false} is VALID [2018-11-23 12:08:54,177 INFO L273 TraceCheckUtils]: 16: Hoare triple {1049#false} ~i~0 := 1;~j~0 := 0; {1049#false} is VALID [2018-11-23 12:08:54,177 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 + 7 * ~j~0), 4); {1049#false} is VALID [2018-11-23 12:08:54,177 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:08:54,178 INFO L273 TraceCheckUtils]: 19: Hoare triple {1049#false} ~cond := #in~cond; {1049#false} is VALID [2018-11-23 12:08:54,178 INFO L273 TraceCheckUtils]: 20: Hoare triple {1049#false} assume 0 == ~cond; {1049#false} is VALID [2018-11-23 12:08:54,178 INFO L273 TraceCheckUtils]: 21: Hoare triple {1049#false} assume !false; {1049#false} is VALID [2018-11-23 12:08:54,179 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:08:54,180 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:08:54,180 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:08:54,188 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:08:54,236 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:08:54,236 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:08:54,262 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:54,263 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:08:54,448 INFO L256 TraceCheckUtils]: 0: Hoare triple {1048#true} call ULTIMATE.init(); {1048#true} is VALID [2018-11-23 12:08:54,449 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:08:54,449 INFO L273 TraceCheckUtils]: 2: Hoare triple {1048#true} assume true; {1048#true} is VALID [2018-11-23 12:08:54,450 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1048#true} {1048#true} #60#return; {1048#true} is VALID [2018-11-23 12:08:54,450 INFO L256 TraceCheckUtils]: 4: Hoare triple {1048#true} call #t~ret4 := main(); {1048#true} is VALID [2018-11-23 12:08:54,451 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:08:54,452 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:08:54,453 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:08:54,454 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:08:54,456 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:08:54,457 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:08:54,458 INFO L273 TraceCheckUtils]: 11: Hoare triple {1055#(<= main_~i~0 5)} assume !(~i~0 < 100000); {1049#false} is VALID [2018-11-23 12:08:54,459 INFO L273 TraceCheckUtils]: 12: Hoare triple {1049#false} ~i~0 := 1; {1049#false} is VALID [2018-11-23 12:08:54,459 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1049#false} is VALID [2018-11-23 12:08:54,459 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1049#false} is VALID [2018-11-23 12:08:54,460 INFO L273 TraceCheckUtils]: 15: Hoare triple {1049#false} assume !(~i~0 < 100000); {1049#false} is VALID [2018-11-23 12:08:54,460 INFO L273 TraceCheckUtils]: 16: Hoare triple {1049#false} ~i~0 := 1;~j~0 := 0; {1049#false} is VALID [2018-11-23 12:08:54,460 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 + 7 * ~j~0), 4); {1049#false} is VALID [2018-11-23 12:08:54,461 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:08:54,461 INFO L273 TraceCheckUtils]: 19: Hoare triple {1049#false} ~cond := #in~cond; {1049#false} is VALID [2018-11-23 12:08:54,462 INFO L273 TraceCheckUtils]: 20: Hoare triple {1049#false} assume 0 == ~cond; {1049#false} is VALID [2018-11-23 12:08:54,462 INFO L273 TraceCheckUtils]: 21: Hoare triple {1049#false} assume !false; {1049#false} is VALID [2018-11-23 12:08:54,463 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:08:54,482 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:08:54,482 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [8, 8] total 9 [2018-11-23 12:08:54,483 INFO L78 Accepts]: Start accepts. Automaton has 9 states. Word has length 22 [2018-11-23 12:08:54,483 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:08:54,483 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 9 states. [2018-11-23 12:08:54,542 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:08:54,542 INFO L459 AbstractCegarLoop]: Interpolant automaton has 9 states [2018-11-23 12:08:54,543 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 9 interpolants. [2018-11-23 12:08:54,543 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=36, Invalid=36, Unknown=0, NotChecked=0, Total=72 [2018-11-23 12:08:54,543 INFO L87 Difference]: Start difference. First operand 26 states and 28 transitions. Second operand 9 states. [2018-11-23 12:08:54,926 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:54,926 INFO L93 Difference]: Finished difference Result 44 states and 49 transitions. [2018-11-23 12:08:54,926 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 8 states. [2018-11-23 12:08:54,927 INFO L78 Accepts]: Start accepts. Automaton has 9 states. Word has length 22 [2018-11-23 12:08:54,927 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:08:54,927 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 9 states. [2018-11-23 12:08:54,929 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 8 states to 8 states and 46 transitions. [2018-11-23 12:08:54,929 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 9 states. [2018-11-23 12:08:54,931 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 8 states to 8 states and 46 transitions. [2018-11-23 12:08:54,931 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 8 states and 46 transitions. [2018-11-23 12:08:54,985 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:08:54,987 INFO L225 Difference]: With dead ends: 44 [2018-11-23 12:08:54,987 INFO L226 Difference]: Without dead ends: 30 [2018-11-23 12:08:54,988 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:08:54,989 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 30 states. [2018-11-23 12:08:55,026 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 30 to 27. [2018-11-23 12:08:55,026 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:08:55,026 INFO L82 GeneralOperation]: Start isEquivalent. First operand 30 states. Second operand 27 states. [2018-11-23 12:08:55,027 INFO L74 IsIncluded]: Start isIncluded. First operand 30 states. Second operand 27 states. [2018-11-23 12:08:55,027 INFO L87 Difference]: Start difference. First operand 30 states. Second operand 27 states. [2018-11-23 12:08:55,029 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:55,030 INFO L93 Difference]: Finished difference Result 30 states and 33 transitions. [2018-11-23 12:08:55,030 INFO L276 IsEmpty]: Start isEmpty. Operand 30 states and 33 transitions. [2018-11-23 12:08:55,031 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:55,031 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:55,031 INFO L74 IsIncluded]: Start isIncluded. First operand 27 states. Second operand 30 states. [2018-11-23 12:08:55,031 INFO L87 Difference]: Start difference. First operand 27 states. Second operand 30 states. [2018-11-23 12:08:55,033 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:55,033 INFO L93 Difference]: Finished difference Result 30 states and 33 transitions. [2018-11-23 12:08:55,034 INFO L276 IsEmpty]: Start isEmpty. Operand 30 states and 33 transitions. [2018-11-23 12:08:55,034 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:55,034 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:55,034 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:08:55,035 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:08:55,035 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 27 states. [2018-11-23 12:08:55,036 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 27 states to 27 states and 29 transitions. [2018-11-23 12:08:55,037 INFO L78 Accepts]: Start accepts. Automaton has 27 states and 29 transitions. Word has length 22 [2018-11-23 12:08:55,037 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:08:55,037 INFO L480 AbstractCegarLoop]: Abstraction has 27 states and 29 transitions. [2018-11-23 12:08:55,037 INFO L481 AbstractCegarLoop]: Interpolant automaton has 9 states. [2018-11-23 12:08:55,037 INFO L276 IsEmpty]: Start isEmpty. Operand 27 states and 29 transitions. [2018-11-23 12:08:55,038 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 24 [2018-11-23 12:08:55,038 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:08:55,038 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:08:55,038 INFO L423 AbstractCegarLoop]: === Iteration 8 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:08:55,039 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:08:55,039 INFO L82 PathProgramCache]: Analyzing trace with hash -532864634, now seen corresponding path program 5 times [2018-11-23 12:08:55,039 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:08:55,039 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:08:55,040 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:55,040 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:08:55,040 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:55,060 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:55,219 INFO L256 TraceCheckUtils]: 0: Hoare triple {1295#true} call ULTIMATE.init(); {1295#true} is VALID [2018-11-23 12:08:55,219 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:08:55,219 INFO L273 TraceCheckUtils]: 2: Hoare triple {1295#true} assume true; {1295#true} is VALID [2018-11-23 12:08:55,219 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1295#true} {1295#true} #60#return; {1295#true} is VALID [2018-11-23 12:08:55,220 INFO L256 TraceCheckUtils]: 4: Hoare triple {1295#true} call #t~ret4 := main(); {1295#true} is VALID [2018-11-23 12:08:55,227 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:08:55,229 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:08:55,230 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:08:55,230 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:08:55,231 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:08:55,232 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:08:55,233 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:08:55,234 INFO L273 TraceCheckUtils]: 12: Hoare triple {1303#(<= main_~i~0 6)} assume !(~i~0 < 100000); {1296#false} is VALID [2018-11-23 12:08:55,234 INFO L273 TraceCheckUtils]: 13: Hoare triple {1296#false} ~i~0 := 1; {1296#false} is VALID [2018-11-23 12:08:55,235 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1296#false} is VALID [2018-11-23 12:08:55,235 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1296#false} is VALID [2018-11-23 12:08:55,236 INFO L273 TraceCheckUtils]: 16: Hoare triple {1296#false} assume !(~i~0 < 100000); {1296#false} is VALID [2018-11-23 12:08:55,236 INFO L273 TraceCheckUtils]: 17: Hoare triple {1296#false} ~i~0 := 1;~j~0 := 0; {1296#false} is VALID [2018-11-23 12:08:55,236 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 + 7 * ~j~0), 4); {1296#false} is VALID [2018-11-23 12:08:55,237 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:08:55,237 INFO L273 TraceCheckUtils]: 20: Hoare triple {1296#false} ~cond := #in~cond; {1296#false} is VALID [2018-11-23 12:08:55,238 INFO L273 TraceCheckUtils]: 21: Hoare triple {1296#false} assume 0 == ~cond; {1296#false} is VALID [2018-11-23 12:08:55,238 INFO L273 TraceCheckUtils]: 22: Hoare triple {1296#false} assume !false; {1296#false} is VALID [2018-11-23 12:08:55,239 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:08:55,239 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:08:55,239 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:08:55,250 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:08:55,301 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 4 check-sat command(s) [2018-11-23 12:08:55,301 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:08:55,312 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:55,314 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:08:55,425 INFO L256 TraceCheckUtils]: 0: Hoare triple {1295#true} call ULTIMATE.init(); {1295#true} is VALID [2018-11-23 12:08:55,425 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:08:55,426 INFO L273 TraceCheckUtils]: 2: Hoare triple {1295#true} assume true; {1295#true} is VALID [2018-11-23 12:08:55,426 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1295#true} {1295#true} #60#return; {1295#true} is VALID [2018-11-23 12:08:55,427 INFO L256 TraceCheckUtils]: 4: Hoare triple {1295#true} call #t~ret4 := main(); {1295#true} is VALID [2018-11-23 12:08:55,429 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:08:55,430 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:08:55,431 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:08:55,432 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:08:55,433 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:08:55,434 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:08:55,436 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:08:55,437 INFO L273 TraceCheckUtils]: 12: Hoare triple {1303#(<= main_~i~0 6)} assume !(~i~0 < 100000); {1296#false} is VALID [2018-11-23 12:08:55,437 INFO L273 TraceCheckUtils]: 13: Hoare triple {1296#false} ~i~0 := 1; {1296#false} is VALID [2018-11-23 12:08:55,438 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1296#false} is VALID [2018-11-23 12:08:55,438 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1296#false} is VALID [2018-11-23 12:08:55,438 INFO L273 TraceCheckUtils]: 16: Hoare triple {1296#false} assume !(~i~0 < 100000); {1296#false} is VALID [2018-11-23 12:08:55,439 INFO L273 TraceCheckUtils]: 17: Hoare triple {1296#false} ~i~0 := 1;~j~0 := 0; {1296#false} is VALID [2018-11-23 12:08:55,439 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 + 7 * ~j~0), 4); {1296#false} is VALID [2018-11-23 12:08:55,439 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:08:55,440 INFO L273 TraceCheckUtils]: 20: Hoare triple {1296#false} ~cond := #in~cond; {1296#false} is VALID [2018-11-23 12:08:55,440 INFO L273 TraceCheckUtils]: 21: Hoare triple {1296#false} assume 0 == ~cond; {1296#false} is VALID [2018-11-23 12:08:55,440 INFO L273 TraceCheckUtils]: 22: Hoare triple {1296#false} assume !false; {1296#false} is VALID [2018-11-23 12:08:55,441 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:08:55,463 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:08:55,463 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [9, 9] total 10 [2018-11-23 12:08:55,464 INFO L78 Accepts]: Start accepts. Automaton has 10 states. Word has length 23 [2018-11-23 12:08:55,464 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:08:55,464 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 10 states. [2018-11-23 12:08:55,560 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:08:55,560 INFO L459 AbstractCegarLoop]: Interpolant automaton has 10 states [2018-11-23 12:08:55,561 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 10 interpolants. [2018-11-23 12:08:55,561 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=45, Invalid=45, Unknown=0, NotChecked=0, Total=90 [2018-11-23 12:08:55,561 INFO L87 Difference]: Start difference. First operand 27 states and 29 transitions. Second operand 10 states. [2018-11-23 12:08:55,885 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:55,885 INFO L93 Difference]: Finished difference Result 45 states and 50 transitions. [2018-11-23 12:08:55,885 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 9 states. [2018-11-23 12:08:55,886 INFO L78 Accepts]: Start accepts. Automaton has 10 states. Word has length 23 [2018-11-23 12:08:55,886 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:08:55,886 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 10 states. [2018-11-23 12:08:55,888 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 9 states to 9 states and 47 transitions. [2018-11-23 12:08:55,888 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 10 states. [2018-11-23 12:08:55,890 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 9 states to 9 states and 47 transitions. [2018-11-23 12:08:55,890 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 9 states and 47 transitions. [2018-11-23 12:08:56,013 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:08:56,016 INFO L225 Difference]: With dead ends: 45 [2018-11-23 12:08:56,016 INFO L226 Difference]: Without dead ends: 31 [2018-11-23 12:08:56,017 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:08:56,017 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 31 states. [2018-11-23 12:08:56,096 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 31 to 28. [2018-11-23 12:08:56,096 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:08:56,096 INFO L82 GeneralOperation]: Start isEquivalent. First operand 31 states. Second operand 28 states. [2018-11-23 12:08:56,096 INFO L74 IsIncluded]: Start isIncluded. First operand 31 states. Second operand 28 states. [2018-11-23 12:08:56,097 INFO L87 Difference]: Start difference. First operand 31 states. Second operand 28 states. [2018-11-23 12:08:56,100 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:56,100 INFO L93 Difference]: Finished difference Result 31 states and 34 transitions. [2018-11-23 12:08:56,100 INFO L276 IsEmpty]: Start isEmpty. Operand 31 states and 34 transitions. [2018-11-23 12:08:56,101 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:56,101 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:56,101 INFO L74 IsIncluded]: Start isIncluded. First operand 28 states. Second operand 31 states. [2018-11-23 12:08:56,101 INFO L87 Difference]: Start difference. First operand 28 states. Second operand 31 states. [2018-11-23 12:08:56,103 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:56,103 INFO L93 Difference]: Finished difference Result 31 states and 34 transitions. [2018-11-23 12:08:56,103 INFO L276 IsEmpty]: Start isEmpty. Operand 31 states and 34 transitions. [2018-11-23 12:08:56,104 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:56,104 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:56,104 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:08:56,104 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:08:56,104 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 28 states. [2018-11-23 12:08:56,106 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 28 states to 28 states and 30 transitions. [2018-11-23 12:08:56,106 INFO L78 Accepts]: Start accepts. Automaton has 28 states and 30 transitions. Word has length 23 [2018-11-23 12:08:56,106 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:08:56,106 INFO L480 AbstractCegarLoop]: Abstraction has 28 states and 30 transitions. [2018-11-23 12:08:56,106 INFO L481 AbstractCegarLoop]: Interpolant automaton has 10 states. [2018-11-23 12:08:56,107 INFO L276 IsEmpty]: Start isEmpty. Operand 28 states and 30 transitions. [2018-11-23 12:08:56,107 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 25 [2018-11-23 12:08:56,107 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:08:56,107 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:08:56,108 INFO L423 AbstractCegarLoop]: === Iteration 9 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:08:56,108 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:08:56,108 INFO L82 PathProgramCache]: Analyzing trace with hash -1533202006, now seen corresponding path program 6 times [2018-11-23 12:08:56,108 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:08:56,108 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:08:56,109 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:56,109 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:08:56,109 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:56,129 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:56,302 INFO L256 TraceCheckUtils]: 0: Hoare triple {1552#true} call ULTIMATE.init(); {1552#true} is VALID [2018-11-23 12:08:56,303 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:08:56,303 INFO L273 TraceCheckUtils]: 2: Hoare triple {1552#true} assume true; {1552#true} is VALID [2018-11-23 12:08:56,304 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1552#true} {1552#true} #60#return; {1552#true} is VALID [2018-11-23 12:08:56,304 INFO L256 TraceCheckUtils]: 4: Hoare triple {1552#true} call #t~ret4 := main(); {1552#true} is VALID [2018-11-23 12:08:56,306 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:08:56,306 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:08:56,307 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:08:56,308 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:08:56,310 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:08:56,314 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:08:56,319 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:08:56,321 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:08:56,322 INFO L273 TraceCheckUtils]: 13: Hoare triple {1561#(<= main_~i~0 7)} assume !(~i~0 < 100000); {1553#false} is VALID [2018-11-23 12:08:56,322 INFO L273 TraceCheckUtils]: 14: Hoare triple {1553#false} ~i~0 := 1; {1553#false} is VALID [2018-11-23 12:08:56,322 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1553#false} is VALID [2018-11-23 12:08:56,322 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1553#false} is VALID [2018-11-23 12:08:56,322 INFO L273 TraceCheckUtils]: 17: Hoare triple {1553#false} assume !(~i~0 < 100000); {1553#false} is VALID [2018-11-23 12:08:56,323 INFO L273 TraceCheckUtils]: 18: Hoare triple {1553#false} ~i~0 := 1;~j~0 := 0; {1553#false} is VALID [2018-11-23 12:08:56,323 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 + 7 * ~j~0), 4); {1553#false} is VALID [2018-11-23 12:08:56,323 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:08:56,323 INFO L273 TraceCheckUtils]: 21: Hoare triple {1553#false} ~cond := #in~cond; {1553#false} is VALID [2018-11-23 12:08:56,324 INFO L273 TraceCheckUtils]: 22: Hoare triple {1553#false} assume 0 == ~cond; {1553#false} is VALID [2018-11-23 12:08:56,324 INFO L273 TraceCheckUtils]: 23: Hoare triple {1553#false} assume !false; {1553#false} is VALID [2018-11-23 12:08:56,325 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:08:56,325 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:08:56,325 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:08:56,340 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE [2018-11-23 12:08:56,405 INFO L249 tOrderPrioritization]: Assert order MIX_INSIDE_OUTSIDE issued 3 check-sat command(s) [2018-11-23 12:08:56,405 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:08:56,419 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:56,420 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:08:56,504 INFO L256 TraceCheckUtils]: 0: Hoare triple {1552#true} call ULTIMATE.init(); {1552#true} is VALID [2018-11-23 12:08:56,504 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:08:56,504 INFO L273 TraceCheckUtils]: 2: Hoare triple {1552#true} assume true; {1552#true} is VALID [2018-11-23 12:08:56,505 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1552#true} {1552#true} #60#return; {1552#true} is VALID [2018-11-23 12:08:56,505 INFO L256 TraceCheckUtils]: 4: Hoare triple {1552#true} call #t~ret4 := main(); {1552#true} is VALID [2018-11-23 12:08:56,505 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:08:56,506 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:08:56,506 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:08:56,506 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:08:56,507 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:08:56,507 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:08:56,507 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:08:56,507 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:08:56,507 INFO L273 TraceCheckUtils]: 13: Hoare triple {1552#true} assume !(~i~0 < 100000); {1552#true} is VALID [2018-11-23 12:08:56,508 INFO L273 TraceCheckUtils]: 14: Hoare triple {1552#true} ~i~0 := 1; {1555#(<= main_~i~0 1)} is VALID [2018-11-23 12:08:56,509 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1610#(<= main_~i~0 8)} is VALID [2018-11-23 12:08:56,510 INFO L273 TraceCheckUtils]: 16: Hoare triple {1610#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1614#(<= main_~i~0 15)} is VALID [2018-11-23 12:08:56,510 INFO L273 TraceCheckUtils]: 17: Hoare triple {1614#(<= main_~i~0 15)} assume !(~i~0 < 100000); {1553#false} is VALID [2018-11-23 12:08:56,511 INFO L273 TraceCheckUtils]: 18: Hoare triple {1553#false} ~i~0 := 1;~j~0 := 0; {1553#false} is VALID [2018-11-23 12:08:56,511 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 + 7 * ~j~0), 4); {1553#false} is VALID [2018-11-23 12:08:56,511 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:08:56,512 INFO L273 TraceCheckUtils]: 21: Hoare triple {1553#false} ~cond := #in~cond; {1553#false} is VALID [2018-11-23 12:08:56,512 INFO L273 TraceCheckUtils]: 22: Hoare triple {1553#false} assume 0 == ~cond; {1553#false} is VALID [2018-11-23 12:08:56,512 INFO L273 TraceCheckUtils]: 23: Hoare triple {1553#false} assume !false; {1553#false} is VALID [2018-11-23 12:08:56,514 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:08:56,533 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:08:56,533 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [10, 5] total 12 [2018-11-23 12:08:56,534 INFO L78 Accepts]: Start accepts. Automaton has 12 states. Word has length 24 [2018-11-23 12:08:56,534 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:08:56,534 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 12 states. [2018-11-23 12:08:56,568 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:08:56,568 INFO L459 AbstractCegarLoop]: Interpolant automaton has 12 states [2018-11-23 12:08:56,569 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 12 interpolants. [2018-11-23 12:08:56,569 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=66, Invalid=66, Unknown=0, NotChecked=0, Total=132 [2018-11-23 12:08:56,569 INFO L87 Difference]: Start difference. First operand 28 states and 30 transitions. Second operand 12 states. [2018-11-23 12:08:57,448 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:57,448 INFO L93 Difference]: Finished difference Result 55 states and 65 transitions. [2018-11-23 12:08:57,448 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 12 states. [2018-11-23 12:08:57,449 INFO L78 Accepts]: Start accepts. Automaton has 12 states. Word has length 24 [2018-11-23 12:08:57,449 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:08:57,449 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 12 states. [2018-11-23 12:08:57,451 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 12 states to 12 states and 63 transitions. [2018-11-23 12:08:57,452 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 12 states. [2018-11-23 12:08:57,454 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 12 states to 12 states and 63 transitions. [2018-11-23 12:08:57,454 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 12 states and 63 transitions. [2018-11-23 12:08:57,561 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:08:57,565 INFO L225 Difference]: With dead ends: 55 [2018-11-23 12:08:57,565 INFO L226 Difference]: Without dead ends: 41 [2018-11-23 12:08:57,566 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 33 GetRequests, 23 SyntacticMatches, 0 SemanticMatches, 10 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.1s TimeCoverageRelationStatistics Valid=66, Invalid=66, Unknown=0, NotChecked=0, Total=132 [2018-11-23 12:08:57,566 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 41 states. [2018-11-23 12:08:57,596 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 41 to 32. [2018-11-23 12:08:57,596 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:08:57,596 INFO L82 GeneralOperation]: Start isEquivalent. First operand 41 states. Second operand 32 states. [2018-11-23 12:08:57,597 INFO L74 IsIncluded]: Start isIncluded. First operand 41 states. Second operand 32 states. [2018-11-23 12:08:57,597 INFO L87 Difference]: Start difference. First operand 41 states. Second operand 32 states. [2018-11-23 12:08:57,599 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:57,599 INFO L93 Difference]: Finished difference Result 41 states and 46 transitions. [2018-11-23 12:08:57,599 INFO L276 IsEmpty]: Start isEmpty. Operand 41 states and 46 transitions. [2018-11-23 12:08:57,599 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:57,599 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:57,600 INFO L74 IsIncluded]: Start isIncluded. First operand 32 states. Second operand 41 states. [2018-11-23 12:08:57,600 INFO L87 Difference]: Start difference. First operand 32 states. Second operand 41 states. [2018-11-23 12:08:57,602 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:57,602 INFO L93 Difference]: Finished difference Result 41 states and 46 transitions. [2018-11-23 12:08:57,602 INFO L276 IsEmpty]: Start isEmpty. Operand 41 states and 46 transitions. [2018-11-23 12:08:57,602 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:57,602 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:57,602 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:08:57,603 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:08:57,603 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 32 states. [2018-11-23 12:08:57,604 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 32 states to 32 states and 34 transitions. [2018-11-23 12:08:57,604 INFO L78 Accepts]: Start accepts. Automaton has 32 states and 34 transitions. Word has length 24 [2018-11-23 12:08:57,604 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:08:57,604 INFO L480 AbstractCegarLoop]: Abstraction has 32 states and 34 transitions. [2018-11-23 12:08:57,604 INFO L481 AbstractCegarLoop]: Interpolant automaton has 12 states. [2018-11-23 12:08:57,605 INFO L276 IsEmpty]: Start isEmpty. Operand 32 states and 34 transitions. [2018-11-23 12:08:57,605 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 29 [2018-11-23 12:08:57,605 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:08:57,605 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:08:57,606 INFO L423 AbstractCegarLoop]: === Iteration 10 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:08:57,606 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:08:57,606 INFO L82 PathProgramCache]: Analyzing trace with hash 2083735689, now seen corresponding path program 7 times [2018-11-23 12:08:57,606 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:08:57,606 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:08:57,607 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:57,607 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:08:57,607 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:57,631 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:57,901 INFO L256 TraceCheckUtils]: 0: Hoare triple {1860#true} call ULTIMATE.init(); {1860#true} is VALID [2018-11-23 12:08:57,902 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:08:57,902 INFO L273 TraceCheckUtils]: 2: Hoare triple {1860#true} assume true; {1860#true} is VALID [2018-11-23 12:08:57,902 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1860#true} {1860#true} #60#return; {1860#true} is VALID [2018-11-23 12:08:57,902 INFO L256 TraceCheckUtils]: 4: Hoare triple {1860#true} call #t~ret4 := main(); {1860#true} is VALID [2018-11-23 12:08:57,903 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:08:57,904 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:08:57,922 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:08:57,936 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:08:57,950 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:08:57,964 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:08:57,973 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:08:57,980 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:08:57,981 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:08:57,985 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:08:57,987 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:08:57,988 INFO L273 TraceCheckUtils]: 16: Hoare triple {1872#(<= main_~i~0 10)} assume !(~i~0 < 100000); {1861#false} is VALID [2018-11-23 12:08:57,988 INFO L273 TraceCheckUtils]: 17: Hoare triple {1861#false} ~i~0 := 1; {1861#false} is VALID [2018-11-23 12:08:57,988 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1861#false} is VALID [2018-11-23 12:08:57,988 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1861#false} is VALID [2018-11-23 12:08:57,988 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1861#false} is VALID [2018-11-23 12:08:57,989 INFO L273 TraceCheckUtils]: 21: Hoare triple {1861#false} assume !(~i~0 < 100000); {1861#false} is VALID [2018-11-23 12:08:57,989 INFO L273 TraceCheckUtils]: 22: Hoare triple {1861#false} ~i~0 := 1;~j~0 := 0; {1861#false} is VALID [2018-11-23 12:08:57,989 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 + 7 * ~j~0), 4); {1861#false} is VALID [2018-11-23 12:08:57,989 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:08:57,989 INFO L273 TraceCheckUtils]: 25: Hoare triple {1861#false} ~cond := #in~cond; {1861#false} is VALID [2018-11-23 12:08:57,989 INFO L273 TraceCheckUtils]: 26: Hoare triple {1861#false} assume 0 == ~cond; {1861#false} is VALID [2018-11-23 12:08:57,989 INFO L273 TraceCheckUtils]: 27: Hoare triple {1861#false} assume !false; {1861#false} is VALID [2018-11-23 12:08:57,990 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:08:57,991 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:08:57,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 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:08:58,012 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:08:58,047 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:58,071 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:58,072 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:08:58,468 INFO L256 TraceCheckUtils]: 0: Hoare triple {1860#true} call ULTIMATE.init(); {1860#true} is VALID [2018-11-23 12:08:58,468 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:08:58,468 INFO L273 TraceCheckUtils]: 2: Hoare triple {1860#true} assume true; {1860#true} is VALID [2018-11-23 12:08:58,468 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1860#true} {1860#true} #60#return; {1860#true} is VALID [2018-11-23 12:08:58,468 INFO L256 TraceCheckUtils]: 4: Hoare triple {1860#true} call #t~ret4 := main(); {1860#true} is VALID [2018-11-23 12:08:58,469 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:08:58,470 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:08:58,471 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:08:58,472 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:08:58,472 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:08:58,473 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:08:58,474 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:08:58,474 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:08:58,475 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:08:58,477 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:08:58,478 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:08:58,478 INFO L273 TraceCheckUtils]: 16: Hoare triple {1872#(<= main_~i~0 10)} assume !(~i~0 < 100000); {1861#false} is VALID [2018-11-23 12:08:58,479 INFO L273 TraceCheckUtils]: 17: Hoare triple {1861#false} ~i~0 := 1; {1861#false} is VALID [2018-11-23 12:08:58,479 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1861#false} is VALID [2018-11-23 12:08:58,479 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1861#false} is VALID [2018-11-23 12:08:58,480 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {1861#false} is VALID [2018-11-23 12:08:58,480 INFO L273 TraceCheckUtils]: 21: Hoare triple {1861#false} assume !(~i~0 < 100000); {1861#false} is VALID [2018-11-23 12:08:58,480 INFO L273 TraceCheckUtils]: 22: Hoare triple {1861#false} ~i~0 := 1;~j~0 := 0; {1861#false} is VALID [2018-11-23 12:08:58,480 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 + 7 * ~j~0), 4); {1861#false} is VALID [2018-11-23 12:08:58,481 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:08:58,481 INFO L273 TraceCheckUtils]: 25: Hoare triple {1861#false} ~cond := #in~cond; {1861#false} is VALID [2018-11-23 12:08:58,481 INFO L273 TraceCheckUtils]: 26: Hoare triple {1861#false} assume 0 == ~cond; {1861#false} is VALID [2018-11-23 12:08:58,482 INFO L273 TraceCheckUtils]: 27: Hoare triple {1861#false} assume !false; {1861#false} is VALID [2018-11-23 12:08:58,483 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:08:58,505 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:08:58,506 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [13, 13] total 14 [2018-11-23 12:08:58,506 INFO L78 Accepts]: Start accepts. Automaton has 14 states. Word has length 28 [2018-11-23 12:08:58,507 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:08:58,507 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 14 states. [2018-11-23 12:08:58,540 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:08:58,540 INFO L459 AbstractCegarLoop]: Interpolant automaton has 14 states [2018-11-23 12:08:58,540 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 14 interpolants. [2018-11-23 12:08:58,541 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=91, Invalid=91, Unknown=0, NotChecked=0, Total=182 [2018-11-23 12:08:58,541 INFO L87 Difference]: Start difference. First operand 32 states and 34 transitions. Second operand 14 states. [2018-11-23 12:08:58,820 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:58,820 INFO L93 Difference]: Finished difference Result 54 states and 60 transitions. [2018-11-23 12:08:58,820 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 13 states. [2018-11-23 12:08:58,820 INFO L78 Accepts]: Start accepts. Automaton has 14 states. Word has length 28 [2018-11-23 12:08:58,821 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:08:58,821 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 14 states. [2018-11-23 12:08:58,825 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 13 states to 13 states and 56 transitions. [2018-11-23 12:08:58,825 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 14 states. [2018-11-23 12:08:58,827 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 13 states to 13 states and 56 transitions. [2018-11-23 12:08:58,827 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 13 states and 56 transitions. [2018-11-23 12:08:58,888 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:08:58,890 INFO L225 Difference]: With dead ends: 54 [2018-11-23 12:08:58,890 INFO L226 Difference]: Without dead ends: 39 [2018-11-23 12:08:58,891 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 40 GetRequests, 28 SyntacticMatches, 0 SemanticMatches, 12 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 18 ImplicationChecksByTransitivity, 0.3s TimeCoverageRelationStatistics Valid=91, Invalid=91, Unknown=0, NotChecked=0, Total=182 [2018-11-23 12:08:58,891 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 39 states. [2018-11-23 12:08:58,917 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 39 to 33. [2018-11-23 12:08:58,917 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:08:58,917 INFO L82 GeneralOperation]: Start isEquivalent. First operand 39 states. Second operand 33 states. [2018-11-23 12:08:58,917 INFO L74 IsIncluded]: Start isIncluded. First operand 39 states. Second operand 33 states. [2018-11-23 12:08:58,918 INFO L87 Difference]: Start difference. First operand 39 states. Second operand 33 states. [2018-11-23 12:08:58,920 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:58,920 INFO L93 Difference]: Finished difference Result 39 states and 43 transitions. [2018-11-23 12:08:58,921 INFO L276 IsEmpty]: Start isEmpty. Operand 39 states and 43 transitions. [2018-11-23 12:08:58,921 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:58,921 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:58,921 INFO L74 IsIncluded]: Start isIncluded. First operand 33 states. Second operand 39 states. [2018-11-23 12:08:58,921 INFO L87 Difference]: Start difference. First operand 33 states. Second operand 39 states. [2018-11-23 12:08:58,923 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:08:58,923 INFO L93 Difference]: Finished difference Result 39 states and 43 transitions. [2018-11-23 12:08:58,923 INFO L276 IsEmpty]: Start isEmpty. Operand 39 states and 43 transitions. [2018-11-23 12:08:58,924 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:08:58,924 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:08:58,924 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:08:58,924 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:08:58,924 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 33 states. [2018-11-23 12:08:58,925 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 33 states to 33 states and 35 transitions. [2018-11-23 12:08:58,926 INFO L78 Accepts]: Start accepts. Automaton has 33 states and 35 transitions. Word has length 28 [2018-11-23 12:08:58,926 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:08:58,926 INFO L480 AbstractCegarLoop]: Abstraction has 33 states and 35 transitions. [2018-11-23 12:08:58,926 INFO L481 AbstractCegarLoop]: Interpolant automaton has 14 states. [2018-11-23 12:08:58,926 INFO L276 IsEmpty]: Start isEmpty. Operand 33 states and 35 transitions. [2018-11-23 12:08:58,927 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 30 [2018-11-23 12:08:58,927 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:08:58,927 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:08:58,927 INFO L423 AbstractCegarLoop]: === Iteration 11 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:08:58,927 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:08:58,927 INFO L82 PathProgramCache]: Analyzing trace with hash -20205851, now seen corresponding path program 8 times [2018-11-23 12:08:58,927 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:08:58,928 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:08:58,928 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:58,929 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:08:58,929 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:08:58,949 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:59,208 INFO L256 TraceCheckUtils]: 0: Hoare triple {2179#true} call ULTIMATE.init(); {2179#true} is VALID [2018-11-23 12:08:59,209 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:08:59,209 INFO L273 TraceCheckUtils]: 2: Hoare triple {2179#true} assume true; {2179#true} is VALID [2018-11-23 12:08:59,209 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2179#true} {2179#true} #60#return; {2179#true} is VALID [2018-11-23 12:08:59,209 INFO L256 TraceCheckUtils]: 4: Hoare triple {2179#true} call #t~ret4 := main(); {2179#true} is VALID [2018-11-23 12:08:59,209 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:08:59,210 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:08:59,217 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:08:59,218 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:08:59,219 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:08:59,220 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:08:59,220 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:08:59,221 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:08:59,222 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:08:59,223 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:08:59,224 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:08:59,225 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:08:59,225 INFO L273 TraceCheckUtils]: 17: Hoare triple {2192#(<= main_~i~0 11)} assume !(~i~0 < 100000); {2180#false} is VALID [2018-11-23 12:08:59,226 INFO L273 TraceCheckUtils]: 18: Hoare triple {2180#false} ~i~0 := 1; {2180#false} is VALID [2018-11-23 12:08:59,226 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2180#false} is VALID [2018-11-23 12:08:59,226 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2180#false} is VALID [2018-11-23 12:08:59,227 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2180#false} is VALID [2018-11-23 12:08:59,227 INFO L273 TraceCheckUtils]: 22: Hoare triple {2180#false} assume !(~i~0 < 100000); {2180#false} is VALID [2018-11-23 12:08:59,227 INFO L273 TraceCheckUtils]: 23: Hoare triple {2180#false} ~i~0 := 1;~j~0 := 0; {2180#false} is VALID [2018-11-23 12:08:59,227 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 + 7 * ~j~0), 4); {2180#false} is VALID [2018-11-23 12:08:59,227 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:08:59,228 INFO L273 TraceCheckUtils]: 26: Hoare triple {2180#false} ~cond := #in~cond; {2180#false} is VALID [2018-11-23 12:08:59,228 INFO L273 TraceCheckUtils]: 27: Hoare triple {2180#false} assume 0 == ~cond; {2180#false} is VALID [2018-11-23 12:08:59,228 INFO L273 TraceCheckUtils]: 28: Hoare triple {2180#false} assume !false; {2180#false} is VALID [2018-11-23 12:08:59,230 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:08:59,230 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:08:59,230 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:08:59,241 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:08:59,265 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:08:59,265 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:08:59,277 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:08:59,279 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:08:59,681 INFO L256 TraceCheckUtils]: 0: Hoare triple {2179#true} call ULTIMATE.init(); {2179#true} is VALID [2018-11-23 12:08:59,682 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:08:59,682 INFO L273 TraceCheckUtils]: 2: Hoare triple {2179#true} assume true; {2179#true} is VALID [2018-11-23 12:08:59,682 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2179#true} {2179#true} #60#return; {2179#true} is VALID [2018-11-23 12:08:59,682 INFO L256 TraceCheckUtils]: 4: Hoare triple {2179#true} call #t~ret4 := main(); {2179#true} is VALID [2018-11-23 12:08:59,695 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:08:59,712 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:08:59,721 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:08:59,734 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:08:59,747 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:08:59,760 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:08:59,776 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:08:59,785 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:08:59,798 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:08:59,811 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:08:59,824 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:08:59,841 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:08:59,850 INFO L273 TraceCheckUtils]: 17: Hoare triple {2192#(<= main_~i~0 11)} assume !(~i~0 < 100000); {2180#false} is VALID [2018-11-23 12:08:59,850 INFO L273 TraceCheckUtils]: 18: Hoare triple {2180#false} ~i~0 := 1; {2180#false} is VALID [2018-11-23 12:08:59,851 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2180#false} is VALID [2018-11-23 12:08:59,851 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2180#false} is VALID [2018-11-23 12:08:59,851 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2180#false} is VALID [2018-11-23 12:08:59,851 INFO L273 TraceCheckUtils]: 22: Hoare triple {2180#false} assume !(~i~0 < 100000); {2180#false} is VALID [2018-11-23 12:08:59,851 INFO L273 TraceCheckUtils]: 23: Hoare triple {2180#false} ~i~0 := 1;~j~0 := 0; {2180#false} is VALID [2018-11-23 12:08:59,852 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 + 7 * ~j~0), 4); {2180#false} is VALID [2018-11-23 12:08:59,852 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:08:59,852 INFO L273 TraceCheckUtils]: 26: Hoare triple {2180#false} ~cond := #in~cond; {2180#false} is VALID [2018-11-23 12:08:59,852 INFO L273 TraceCheckUtils]: 27: Hoare triple {2180#false} assume 0 == ~cond; {2180#false} is VALID [2018-11-23 12:08:59,852 INFO L273 TraceCheckUtils]: 28: Hoare triple {2180#false} assume !false; {2180#false} is VALID [2018-11-23 12:08:59,853 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:08:59,887 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:08:59,887 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [14, 14] total 15 [2018-11-23 12:08:59,888 INFO L78 Accepts]: Start accepts. Automaton has 15 states. Word has length 29 [2018-11-23 12:08:59,888 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:08:59,888 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 15 states. [2018-11-23 12:08:59,972 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:08:59,972 INFO L459 AbstractCegarLoop]: Interpolant automaton has 15 states [2018-11-23 12:08:59,972 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 15 interpolants. [2018-11-23 12:08:59,973 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=105, Invalid=105, Unknown=0, NotChecked=0, Total=210 [2018-11-23 12:08:59,973 INFO L87 Difference]: Start difference. First operand 33 states and 35 transitions. Second operand 15 states. [2018-11-23 12:09:00,320 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:00,320 INFO L93 Difference]: Finished difference Result 55 states and 61 transitions. [2018-11-23 12:09:00,321 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 14 states. [2018-11-23 12:09:00,321 INFO L78 Accepts]: Start accepts. Automaton has 15 states. Word has length 29 [2018-11-23 12:09:00,321 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:00,322 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 15 states. [2018-11-23 12:09:00,323 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 14 states to 14 states and 57 transitions. [2018-11-23 12:09:00,324 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 15 states. [2018-11-23 12:09:00,325 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 14 states to 14 states and 57 transitions. [2018-11-23 12:09:00,325 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 14 states and 57 transitions. [2018-11-23 12:09:00,418 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:00,419 INFO L225 Difference]: With dead ends: 55 [2018-11-23 12:09:00,420 INFO L226 Difference]: Without dead ends: 40 [2018-11-23 12:09:00,420 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 42 GetRequests, 29 SyntacticMatches, 0 SemanticMatches, 13 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 20 ImplicationChecksByTransitivity, 0.1s TimeCoverageRelationStatistics Valid=105, Invalid=105, Unknown=0, NotChecked=0, Total=210 [2018-11-23 12:09:00,421 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 40 states. [2018-11-23 12:09:00,441 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 40 to 34. [2018-11-23 12:09:00,441 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:00,441 INFO L82 GeneralOperation]: Start isEquivalent. First operand 40 states. Second operand 34 states. [2018-11-23 12:09:00,441 INFO L74 IsIncluded]: Start isIncluded. First operand 40 states. Second operand 34 states. [2018-11-23 12:09:00,442 INFO L87 Difference]: Start difference. First operand 40 states. Second operand 34 states. [2018-11-23 12:09:00,443 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:00,443 INFO L93 Difference]: Finished difference Result 40 states and 44 transitions. [2018-11-23 12:09:00,443 INFO L276 IsEmpty]: Start isEmpty. Operand 40 states and 44 transitions. [2018-11-23 12:09:00,444 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:00,444 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:00,444 INFO L74 IsIncluded]: Start isIncluded. First operand 34 states. Second operand 40 states. [2018-11-23 12:09:00,444 INFO L87 Difference]: Start difference. First operand 34 states. Second operand 40 states. [2018-11-23 12:09:00,445 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:00,445 INFO L93 Difference]: Finished difference Result 40 states and 44 transitions. [2018-11-23 12:09:00,446 INFO L276 IsEmpty]: Start isEmpty. Operand 40 states and 44 transitions. [2018-11-23 12:09:00,446 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:00,446 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:00,446 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:00,446 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:00,446 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 34 states. [2018-11-23 12:09:00,447 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 34 states to 34 states and 36 transitions. [2018-11-23 12:09:00,447 INFO L78 Accepts]: Start accepts. Automaton has 34 states and 36 transitions. Word has length 29 [2018-11-23 12:09:00,448 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:00,448 INFO L480 AbstractCegarLoop]: Abstraction has 34 states and 36 transitions. [2018-11-23 12:09:00,448 INFO L481 AbstractCegarLoop]: Interpolant automaton has 15 states. [2018-11-23 12:09:00,448 INFO L276 IsEmpty]: Start isEmpty. Operand 34 states and 36 transitions. [2018-11-23 12:09:00,449 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 31 [2018-11-23 12:09:00,449 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:00,449 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:00,449 INFO L423 AbstractCegarLoop]: === Iteration 12 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:00,449 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:00,450 INFO L82 PathProgramCache]: Analyzing trace with hash -817884151, now seen corresponding path program 9 times [2018-11-23 12:09:00,450 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:00,450 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:00,451 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:00,451 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:00,451 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:00,490 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:00,932 INFO L256 TraceCheckUtils]: 0: Hoare triple {2508#true} call ULTIMATE.init(); {2508#true} is VALID [2018-11-23 12:09:00,932 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:00,932 INFO L273 TraceCheckUtils]: 2: Hoare triple {2508#true} assume true; {2508#true} is VALID [2018-11-23 12:09:00,933 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2508#true} {2508#true} #60#return; {2508#true} is VALID [2018-11-23 12:09:00,933 INFO L256 TraceCheckUtils]: 4: Hoare triple {2508#true} call #t~ret4 := main(); {2508#true} is VALID [2018-11-23 12:09:00,937 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:00,938 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:00,939 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:00,940 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:00,940 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:00,941 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:00,942 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:00,943 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:00,944 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:00,945 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:00,946 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:00,947 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:00,948 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:00,949 INFO L273 TraceCheckUtils]: 18: Hoare triple {2522#(<= main_~i~0 12)} assume !(~i~0 < 100000); {2509#false} is VALID [2018-11-23 12:09:00,949 INFO L273 TraceCheckUtils]: 19: Hoare triple {2509#false} ~i~0 := 1; {2509#false} is VALID [2018-11-23 12:09:00,950 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2509#false} is VALID [2018-11-23 12:09:00,950 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2509#false} is VALID [2018-11-23 12:09:00,950 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2509#false} is VALID [2018-11-23 12:09:00,950 INFO L273 TraceCheckUtils]: 23: Hoare triple {2509#false} assume !(~i~0 < 100000); {2509#false} is VALID [2018-11-23 12:09:00,951 INFO L273 TraceCheckUtils]: 24: Hoare triple {2509#false} ~i~0 := 1;~j~0 := 0; {2509#false} is VALID [2018-11-23 12:09:00,951 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 + 7 * ~j~0), 4); {2509#false} is VALID [2018-11-23 12:09:00,951 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:00,951 INFO L273 TraceCheckUtils]: 27: Hoare triple {2509#false} ~cond := #in~cond; {2509#false} is VALID [2018-11-23 12:09:00,952 INFO L273 TraceCheckUtils]: 28: Hoare triple {2509#false} assume 0 == ~cond; {2509#false} is VALID [2018-11-23 12:09:00,952 INFO L273 TraceCheckUtils]: 29: Hoare triple {2509#false} assume !false; {2509#false} is VALID [2018-11-23 12:09:00,953 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:00,953 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:00,953 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:00,965 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:09:01,019 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 3 check-sat command(s) [2018-11-23 12:09:01,019 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:01,053 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:01,054 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:01,392 INFO L256 TraceCheckUtils]: 0: Hoare triple {2508#true} call ULTIMATE.init(); {2508#true} is VALID [2018-11-23 12:09:01,393 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:01,393 INFO L273 TraceCheckUtils]: 2: Hoare triple {2508#true} assume true; {2508#true} is VALID [2018-11-23 12:09:01,393 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2508#true} {2508#true} #60#return; {2508#true} is VALID [2018-11-23 12:09:01,393 INFO L256 TraceCheckUtils]: 4: Hoare triple {2508#true} call #t~ret4 := main(); {2508#true} is VALID [2018-11-23 12:09:01,393 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:01,393 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:01,393 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:01,394 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:01,394 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:01,394 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:01,394 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:01,394 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:01,394 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:01,395 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:01,395 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:01,395 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:01,395 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:01,396 INFO L273 TraceCheckUtils]: 18: Hoare triple {2508#true} assume !(~i~0 < 100000); {2508#true} is VALID [2018-11-23 12:09:01,396 INFO L273 TraceCheckUtils]: 19: Hoare triple {2508#true} ~i~0 := 1; {2511#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:01,397 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2518#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:01,398 INFO L273 TraceCheckUtils]: 21: Hoare triple {2518#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2589#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:01,399 INFO L273 TraceCheckUtils]: 22: Hoare triple {2589#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2593#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:01,399 INFO L273 TraceCheckUtils]: 23: Hoare triple {2593#(<= main_~i~0 22)} assume !(~i~0 < 100000); {2509#false} is VALID [2018-11-23 12:09:01,399 INFO L273 TraceCheckUtils]: 24: Hoare triple {2509#false} ~i~0 := 1;~j~0 := 0; {2509#false} is VALID [2018-11-23 12:09:01,400 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 + 7 * ~j~0), 4); {2509#false} is VALID [2018-11-23 12:09:01,400 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:01,400 INFO L273 TraceCheckUtils]: 27: Hoare triple {2509#false} ~cond := #in~cond; {2509#false} is VALID [2018-11-23 12:09:01,400 INFO L273 TraceCheckUtils]: 28: Hoare triple {2509#false} assume 0 == ~cond; {2509#false} is VALID [2018-11-23 12:09:01,401 INFO L273 TraceCheckUtils]: 29: Hoare triple {2509#false} assume !false; {2509#false} is VALID [2018-11-23 12:09:01,402 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:01,421 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:01,421 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [15, 6] total 17 [2018-11-23 12:09:01,421 INFO L78 Accepts]: Start accepts. Automaton has 17 states. Word has length 30 [2018-11-23 12:09:01,422 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:01,422 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 17 states. [2018-11-23 12:09:01,455 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:01,455 INFO L459 AbstractCegarLoop]: Interpolant automaton has 17 states [2018-11-23 12:09:01,455 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 17 interpolants. [2018-11-23 12:09:01,456 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=136, Invalid=136, Unknown=0, NotChecked=0, Total=272 [2018-11-23 12:09:01,456 INFO L87 Difference]: Start difference. First operand 34 states and 36 transitions. Second operand 17 states. [2018-11-23 12:09:02,005 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:02,005 INFO L93 Difference]: Finished difference Result 65 states and 76 transitions. [2018-11-23 12:09:02,005 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 17 states. [2018-11-23 12:09:02,006 INFO L78 Accepts]: Start accepts. Automaton has 17 states. Word has length 30 [2018-11-23 12:09:02,006 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:02,006 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 17 states. [2018-11-23 12:09:02,008 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 17 states to 17 states and 73 transitions. [2018-11-23 12:09:02,008 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 17 states. [2018-11-23 12:09:02,010 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 17 states to 17 states and 73 transitions. [2018-11-23 12:09:02,010 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 17 states and 73 transitions. [2018-11-23 12:09:02,120 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:02,121 INFO L225 Difference]: With dead ends: 65 [2018-11-23 12:09:02,122 INFO L226 Difference]: Without dead ends: 50 [2018-11-23 12:09:02,123 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 44 GetRequests, 29 SyntacticMatches, 0 SemanticMatches, 15 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.3s TimeCoverageRelationStatistics Valid=136, Invalid=136, Unknown=0, NotChecked=0, Total=272 [2018-11-23 12:09:02,123 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 50 states. [2018-11-23 12:09:02,160 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 50 to 38. [2018-11-23 12:09:02,160 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:02,160 INFO L82 GeneralOperation]: Start isEquivalent. First operand 50 states. Second operand 38 states. [2018-11-23 12:09:02,160 INFO L74 IsIncluded]: Start isIncluded. First operand 50 states. Second operand 38 states. [2018-11-23 12:09:02,160 INFO L87 Difference]: Start difference. First operand 50 states. Second operand 38 states. [2018-11-23 12:09:02,162 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:02,162 INFO L93 Difference]: Finished difference Result 50 states and 56 transitions. [2018-11-23 12:09:02,162 INFO L276 IsEmpty]: Start isEmpty. Operand 50 states and 56 transitions. [2018-11-23 12:09:02,163 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:02,163 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:02,163 INFO L74 IsIncluded]: Start isIncluded. First operand 38 states. Second operand 50 states. [2018-11-23 12:09:02,163 INFO L87 Difference]: Start difference. First operand 38 states. Second operand 50 states. [2018-11-23 12:09:02,165 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:02,165 INFO L93 Difference]: Finished difference Result 50 states and 56 transitions. [2018-11-23 12:09:02,165 INFO L276 IsEmpty]: Start isEmpty. Operand 50 states and 56 transitions. [2018-11-23 12:09:02,165 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:02,165 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:02,166 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:02,166 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:02,166 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 38 states. [2018-11-23 12:09:02,167 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 38 states to 38 states and 40 transitions. [2018-11-23 12:09:02,167 INFO L78 Accepts]: Start accepts. Automaton has 38 states and 40 transitions. Word has length 30 [2018-11-23 12:09:02,167 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:02,167 INFO L480 AbstractCegarLoop]: Abstraction has 38 states and 40 transitions. [2018-11-23 12:09:02,167 INFO L481 AbstractCegarLoop]: Interpolant automaton has 17 states. [2018-11-23 12:09:02,167 INFO L276 IsEmpty]: Start isEmpty. Operand 38 states and 40 transitions. [2018-11-23 12:09:02,168 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 35 [2018-11-23 12:09:02,168 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:02,168 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:02,168 INFO L423 AbstractCegarLoop]: === Iteration 13 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:02,169 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:02,169 INFO L82 PathProgramCache]: Analyzing trace with hash 1076963082, now seen corresponding path program 10 times [2018-11-23 12:09:02,169 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:02,169 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:02,170 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:02,170 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:02,170 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:02,189 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:02,475 INFO L256 TraceCheckUtils]: 0: Hoare triple {2888#true} call ULTIMATE.init(); {2888#true} is VALID [2018-11-23 12:09:02,475 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:02,475 INFO L273 TraceCheckUtils]: 2: Hoare triple {2888#true} assume true; {2888#true} is VALID [2018-11-23 12:09:02,476 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2888#true} {2888#true} #60#return; {2888#true} is VALID [2018-11-23 12:09:02,476 INFO L256 TraceCheckUtils]: 4: Hoare triple {2888#true} call #t~ret4 := main(); {2888#true} is VALID [2018-11-23 12:09:02,476 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:02,477 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:02,479 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:02,480 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:02,481 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:02,482 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:02,483 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:02,484 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:02,485 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:02,486 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:02,487 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:02,488 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:02,490 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:02,491 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:02,492 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:02,493 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:02,494 INFO L273 TraceCheckUtils]: 21: Hoare triple {2905#(<= main_~i~0 15)} assume !(~i~0 < 100000); {2889#false} is VALID [2018-11-23 12:09:02,494 INFO L273 TraceCheckUtils]: 22: Hoare triple {2889#false} ~i~0 := 1; {2889#false} is VALID [2018-11-23 12:09:02,494 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:02,495 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:02,495 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:02,495 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:02,495 INFO L273 TraceCheckUtils]: 27: Hoare triple {2889#false} assume !(~i~0 < 100000); {2889#false} is VALID [2018-11-23 12:09:02,496 INFO L273 TraceCheckUtils]: 28: Hoare triple {2889#false} ~i~0 := 1;~j~0 := 0; {2889#false} is VALID [2018-11-23 12:09:02,496 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 + 7 * ~j~0), 4); {2889#false} is VALID [2018-11-23 12:09:02,496 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:02,496 INFO L273 TraceCheckUtils]: 31: Hoare triple {2889#false} ~cond := #in~cond; {2889#false} is VALID [2018-11-23 12:09:02,496 INFO L273 TraceCheckUtils]: 32: Hoare triple {2889#false} assume 0 == ~cond; {2889#false} is VALID [2018-11-23 12:09:02,497 INFO L273 TraceCheckUtils]: 33: Hoare triple {2889#false} assume !false; {2889#false} is VALID [2018-11-23 12:09:02,498 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:02,498 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:02,498 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:02,507 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:09:02,559 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:09:02,559 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:02,574 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:02,575 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:02,795 INFO L256 TraceCheckUtils]: 0: Hoare triple {2888#true} call ULTIMATE.init(); {2888#true} is VALID [2018-11-23 12:09:02,796 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:02,796 INFO L273 TraceCheckUtils]: 2: Hoare triple {2888#true} assume true; {2888#true} is VALID [2018-11-23 12:09:02,796 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2888#true} {2888#true} #60#return; {2888#true} is VALID [2018-11-23 12:09:02,797 INFO L256 TraceCheckUtils]: 4: Hoare triple {2888#true} call #t~ret4 := main(); {2888#true} is VALID [2018-11-23 12:09:02,798 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:02,799 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:02,799 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:02,800 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:02,801 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:02,802 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:02,804 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:02,820 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:02,821 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:02,822 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:02,823 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:02,823 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:02,824 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:02,825 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:02,825 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:02,827 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:02,827 INFO L273 TraceCheckUtils]: 21: Hoare triple {2905#(<= main_~i~0 15)} assume !(~i~0 < 100000); {2889#false} is VALID [2018-11-23 12:09:02,828 INFO L273 TraceCheckUtils]: 22: Hoare triple {2889#false} ~i~0 := 1; {2889#false} is VALID [2018-11-23 12:09:02,828 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:02,828 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:02,828 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:02,829 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {2889#false} is VALID [2018-11-23 12:09:02,829 INFO L273 TraceCheckUtils]: 27: Hoare triple {2889#false} assume !(~i~0 < 100000); {2889#false} is VALID [2018-11-23 12:09:02,829 INFO L273 TraceCheckUtils]: 28: Hoare triple {2889#false} ~i~0 := 1;~j~0 := 0; {2889#false} is VALID [2018-11-23 12:09:02,830 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 + 7 * ~j~0), 4); {2889#false} is VALID [2018-11-23 12:09:02,830 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:02,830 INFO L273 TraceCheckUtils]: 31: Hoare triple {2889#false} ~cond := #in~cond; {2889#false} is VALID [2018-11-23 12:09:02,830 INFO L273 TraceCheckUtils]: 32: Hoare triple {2889#false} assume 0 == ~cond; {2889#false} is VALID [2018-11-23 12:09:02,831 INFO L273 TraceCheckUtils]: 33: Hoare triple {2889#false} assume !false; {2889#false} is VALID [2018-11-23 12:09:02,832 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:02,853 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:02,853 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [18, 18] total 19 [2018-11-23 12:09:02,853 INFO L78 Accepts]: Start accepts. Automaton has 19 states. Word has length 34 [2018-11-23 12:09:02,854 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:02,854 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 19 states. [2018-11-23 12:09:02,878 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:02,878 INFO L459 AbstractCegarLoop]: Interpolant automaton has 19 states [2018-11-23 12:09:02,878 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 19 interpolants. [2018-11-23 12:09:02,879 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=171, Invalid=171, Unknown=0, NotChecked=0, Total=342 [2018-11-23 12:09:02,879 INFO L87 Difference]: Start difference. First operand 38 states and 40 transitions. Second operand 19 states. [2018-11-23 12:09:03,452 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:03,453 INFO L93 Difference]: Finished difference Result 64 states and 71 transitions. [2018-11-23 12:09:03,453 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 18 states. [2018-11-23 12:09:03,453 INFO L78 Accepts]: Start accepts. Automaton has 19 states. Word has length 34 [2018-11-23 12:09:03,453 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:03,453 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 19 states. [2018-11-23 12:09:03,455 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 18 states to 18 states and 66 transitions. [2018-11-23 12:09:03,455 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 19 states. [2018-11-23 12:09:03,457 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 18 states to 18 states and 66 transitions. [2018-11-23 12:09:03,457 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 18 states and 66 transitions. [2018-11-23 12:09:03,537 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 66 edges. 66 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:03,538 INFO L225 Difference]: With dead ends: 64 [2018-11-23 12:09:03,539 INFO L226 Difference]: Without dead ends: 48 [2018-11-23 12:09:03,540 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 51 GetRequests, 34 SyntacticMatches, 0 SemanticMatches, 17 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 28 ImplicationChecksByTransitivity, 0.1s TimeCoverageRelationStatistics Valid=171, Invalid=171, Unknown=0, NotChecked=0, Total=342 [2018-11-23 12:09:03,540 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 48 states. [2018-11-23 12:09:03,575 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 48 to 39. [2018-11-23 12:09:03,576 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:03,576 INFO L82 GeneralOperation]: Start isEquivalent. First operand 48 states. Second operand 39 states. [2018-11-23 12:09:03,576 INFO L74 IsIncluded]: Start isIncluded. First operand 48 states. Second operand 39 states. [2018-11-23 12:09:03,576 INFO L87 Difference]: Start difference. First operand 48 states. Second operand 39 states. [2018-11-23 12:09:03,578 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:03,578 INFO L93 Difference]: Finished difference Result 48 states and 53 transitions. [2018-11-23 12:09:03,578 INFO L276 IsEmpty]: Start isEmpty. Operand 48 states and 53 transitions. [2018-11-23 12:09:03,579 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:03,579 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:03,579 INFO L74 IsIncluded]: Start isIncluded. First operand 39 states. Second operand 48 states. [2018-11-23 12:09:03,579 INFO L87 Difference]: Start difference. First operand 39 states. Second operand 48 states. [2018-11-23 12:09:03,581 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:03,581 INFO L93 Difference]: Finished difference Result 48 states and 53 transitions. [2018-11-23 12:09:03,581 INFO L276 IsEmpty]: Start isEmpty. Operand 48 states and 53 transitions. [2018-11-23 12:09:03,581 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:03,581 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:03,581 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:03,582 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:03,582 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 39 states. [2018-11-23 12:09:03,583 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 39 states to 39 states and 41 transitions. [2018-11-23 12:09:03,583 INFO L78 Accepts]: Start accepts. Automaton has 39 states and 41 transitions. Word has length 34 [2018-11-23 12:09:03,583 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:03,583 INFO L480 AbstractCegarLoop]: Abstraction has 39 states and 41 transitions. [2018-11-23 12:09:03,583 INFO L481 AbstractCegarLoop]: Interpolant automaton has 19 states. [2018-11-23 12:09:03,583 INFO L276 IsEmpty]: Start isEmpty. Operand 39 states and 41 transitions. [2018-11-23 12:09:03,584 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 36 [2018-11-23 12:09:03,584 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:03,584 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:03,584 INFO L423 AbstractCegarLoop]: === Iteration 14 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:03,585 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:03,585 INFO L82 PathProgramCache]: Analyzing trace with hash 790780006, now seen corresponding path program 11 times [2018-11-23 12:09:03,585 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:03,585 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:03,586 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:03,586 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:03,586 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:03,605 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:04,060 INFO L256 TraceCheckUtils]: 0: Hoare triple {3279#true} call ULTIMATE.init(); {3279#true} is VALID [2018-11-23 12:09:04,060 INFO L273 TraceCheckUtils]: 1: Hoare triple {3279#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {3279#true} is VALID [2018-11-23 12:09:04,061 INFO L273 TraceCheckUtils]: 2: Hoare triple {3279#true} assume true; {3279#true} is VALID [2018-11-23 12:09:04,061 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3279#true} {3279#true} #60#return; {3279#true} is VALID [2018-11-23 12:09:04,061 INFO L256 TraceCheckUtils]: 4: Hoare triple {3279#true} call #t~ret4 := main(); {3279#true} is VALID [2018-11-23 12:09:04,061 INFO L273 TraceCheckUtils]: 5: Hoare triple {3279#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; {3281#(= main_~i~0 0)} is VALID [2018-11-23 12:09:04,062 INFO L273 TraceCheckUtils]: 6: Hoare triple {3281#(= 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; {3282#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:04,063 INFO L273 TraceCheckUtils]: 7: Hoare triple {3282#(<= 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; {3283#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:04,064 INFO L273 TraceCheckUtils]: 8: Hoare triple {3283#(<= 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; {3284#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:04,065 INFO L273 TraceCheckUtils]: 9: Hoare triple {3284#(<= 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; {3285#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:04,067 INFO L273 TraceCheckUtils]: 10: Hoare triple {3285#(<= 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; {3286#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:04,068 INFO L273 TraceCheckUtils]: 11: Hoare triple {3286#(<= 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; {3287#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:04,069 INFO L273 TraceCheckUtils]: 12: Hoare triple {3287#(<= 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; {3288#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:04,070 INFO L273 TraceCheckUtils]: 13: Hoare triple {3288#(<= 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; {3289#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:04,071 INFO L273 TraceCheckUtils]: 14: Hoare triple {3289#(<= 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; {3290#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:04,072 INFO L273 TraceCheckUtils]: 15: Hoare triple {3290#(<= 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; {3291#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:04,074 INFO L273 TraceCheckUtils]: 16: Hoare triple {3291#(<= 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; {3292#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:04,075 INFO L273 TraceCheckUtils]: 17: Hoare triple {3292#(<= 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; {3293#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:04,076 INFO L273 TraceCheckUtils]: 18: Hoare triple {3293#(<= 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; {3294#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:04,077 INFO L273 TraceCheckUtils]: 19: Hoare triple {3294#(<= 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; {3295#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:04,078 INFO L273 TraceCheckUtils]: 20: Hoare triple {3295#(<= 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; {3296#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:04,079 INFO L273 TraceCheckUtils]: 21: Hoare triple {3296#(<= 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; {3297#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:04,080 INFO L273 TraceCheckUtils]: 22: Hoare triple {3297#(<= main_~i~0 16)} assume !(~i~0 < 100000); {3280#false} is VALID [2018-11-23 12:09:04,081 INFO L273 TraceCheckUtils]: 23: Hoare triple {3280#false} ~i~0 := 1; {3280#false} is VALID [2018-11-23 12:09:04,081 INFO L273 TraceCheckUtils]: 24: Hoare triple {3280#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3280#false} is VALID [2018-11-23 12:09:04,081 INFO L273 TraceCheckUtils]: 25: Hoare triple {3280#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3280#false} is VALID [2018-11-23 12:09:04,081 INFO L273 TraceCheckUtils]: 26: Hoare triple {3280#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3280#false} is VALID [2018-11-23 12:09:04,082 INFO L273 TraceCheckUtils]: 27: Hoare triple {3280#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3280#false} is VALID [2018-11-23 12:09:04,082 INFO L273 TraceCheckUtils]: 28: Hoare triple {3280#false} assume !(~i~0 < 100000); {3280#false} is VALID [2018-11-23 12:09:04,082 INFO L273 TraceCheckUtils]: 29: Hoare triple {3280#false} ~i~0 := 1;~j~0 := 0; {3280#false} is VALID [2018-11-23 12:09:04,082 INFO L273 TraceCheckUtils]: 30: Hoare triple {3280#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 + 7 * ~j~0), 4); {3280#false} is VALID [2018-11-23 12:09:04,083 INFO L256 TraceCheckUtils]: 31: Hoare triple {3280#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {3280#false} is VALID [2018-11-23 12:09:04,083 INFO L273 TraceCheckUtils]: 32: Hoare triple {3280#false} ~cond := #in~cond; {3280#false} is VALID [2018-11-23 12:09:04,083 INFO L273 TraceCheckUtils]: 33: Hoare triple {3280#false} assume 0 == ~cond; {3280#false} is VALID [2018-11-23 12:09:04,083 INFO L273 TraceCheckUtils]: 34: Hoare triple {3280#false} assume !false; {3280#false} is VALID [2018-11-23 12:09:04,085 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:04,085 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:04,085 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:04,111 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:09:04,413 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 9 check-sat command(s) [2018-11-23 12:09:04,413 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:04,439 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:04,440 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:04,587 INFO L256 TraceCheckUtils]: 0: Hoare triple {3279#true} call ULTIMATE.init(); {3279#true} is VALID [2018-11-23 12:09:04,587 INFO L273 TraceCheckUtils]: 1: Hoare triple {3279#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {3279#true} is VALID [2018-11-23 12:09:04,587 INFO L273 TraceCheckUtils]: 2: Hoare triple {3279#true} assume true; {3279#true} is VALID [2018-11-23 12:09:04,587 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3279#true} {3279#true} #60#return; {3279#true} is VALID [2018-11-23 12:09:04,588 INFO L256 TraceCheckUtils]: 4: Hoare triple {3279#true} call #t~ret4 := main(); {3279#true} is VALID [2018-11-23 12:09:04,589 INFO L273 TraceCheckUtils]: 5: Hoare triple {3279#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; {3316#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:04,589 INFO L273 TraceCheckUtils]: 6: Hoare triple {3316#(<= 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; {3282#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:04,590 INFO L273 TraceCheckUtils]: 7: Hoare triple {3282#(<= 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; {3283#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:04,591 INFO L273 TraceCheckUtils]: 8: Hoare triple {3283#(<= 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; {3284#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:04,592 INFO L273 TraceCheckUtils]: 9: Hoare triple {3284#(<= 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; {3285#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:04,593 INFO L273 TraceCheckUtils]: 10: Hoare triple {3285#(<= 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; {3286#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:04,594 INFO L273 TraceCheckUtils]: 11: Hoare triple {3286#(<= 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; {3287#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:04,595 INFO L273 TraceCheckUtils]: 12: Hoare triple {3287#(<= 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; {3288#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:04,596 INFO L273 TraceCheckUtils]: 13: Hoare triple {3288#(<= 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; {3289#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:04,597 INFO L273 TraceCheckUtils]: 14: Hoare triple {3289#(<= 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; {3290#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:04,598 INFO L273 TraceCheckUtils]: 15: Hoare triple {3290#(<= 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; {3291#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:04,599 INFO L273 TraceCheckUtils]: 16: Hoare triple {3291#(<= 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; {3292#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:04,600 INFO L273 TraceCheckUtils]: 17: Hoare triple {3292#(<= 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; {3293#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:04,611 INFO L273 TraceCheckUtils]: 18: Hoare triple {3293#(<= 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; {3294#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:04,612 INFO L273 TraceCheckUtils]: 19: Hoare triple {3294#(<= 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; {3295#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:04,613 INFO L273 TraceCheckUtils]: 20: Hoare triple {3295#(<= 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; {3296#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:04,613 INFO L273 TraceCheckUtils]: 21: Hoare triple {3296#(<= 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; {3297#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:04,614 INFO L273 TraceCheckUtils]: 22: Hoare triple {3297#(<= main_~i~0 16)} assume !(~i~0 < 100000); {3280#false} is VALID [2018-11-23 12:09:04,614 INFO L273 TraceCheckUtils]: 23: Hoare triple {3280#false} ~i~0 := 1; {3280#false} is VALID [2018-11-23 12:09:04,614 INFO L273 TraceCheckUtils]: 24: Hoare triple {3280#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3280#false} is VALID [2018-11-23 12:09:04,614 INFO L273 TraceCheckUtils]: 25: Hoare triple {3280#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3280#false} is VALID [2018-11-23 12:09:04,614 INFO L273 TraceCheckUtils]: 26: Hoare triple {3280#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3280#false} is VALID [2018-11-23 12:09:04,615 INFO L273 TraceCheckUtils]: 27: Hoare triple {3280#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3280#false} is VALID [2018-11-23 12:09:04,615 INFO L273 TraceCheckUtils]: 28: Hoare triple {3280#false} assume !(~i~0 < 100000); {3280#false} is VALID [2018-11-23 12:09:04,615 INFO L273 TraceCheckUtils]: 29: Hoare triple {3280#false} ~i~0 := 1;~j~0 := 0; {3280#false} is VALID [2018-11-23 12:09:04,615 INFO L273 TraceCheckUtils]: 30: Hoare triple {3280#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 + 7 * ~j~0), 4); {3280#false} is VALID [2018-11-23 12:09:04,615 INFO L256 TraceCheckUtils]: 31: Hoare triple {3280#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {3280#false} is VALID [2018-11-23 12:09:04,615 INFO L273 TraceCheckUtils]: 32: Hoare triple {3280#false} ~cond := #in~cond; {3280#false} is VALID [2018-11-23 12:09:04,615 INFO L273 TraceCheckUtils]: 33: Hoare triple {3280#false} assume 0 == ~cond; {3280#false} is VALID [2018-11-23 12:09:04,615 INFO L273 TraceCheckUtils]: 34: Hoare triple {3280#false} assume !false; {3280#false} is VALID [2018-11-23 12:09:04,616 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:04,637 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:04,637 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [19, 19] total 20 [2018-11-23 12:09:04,638 INFO L78 Accepts]: Start accepts. Automaton has 20 states. Word has length 35 [2018-11-23 12:09:04,638 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:04,638 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 20 states. [2018-11-23 12:09:04,664 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:04,664 INFO L459 AbstractCegarLoop]: Interpolant automaton has 20 states [2018-11-23 12:09:04,665 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 20 interpolants. [2018-11-23 12:09:04,665 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=190, Invalid=190, Unknown=0, NotChecked=0, Total=380 [2018-11-23 12:09:04,665 INFO L87 Difference]: Start difference. First operand 39 states and 41 transitions. Second operand 20 states. [2018-11-23 12:09:05,024 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:05,024 INFO L93 Difference]: Finished difference Result 65 states and 72 transitions. [2018-11-23 12:09:05,024 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 19 states. [2018-11-23 12:09:05,024 INFO L78 Accepts]: Start accepts. Automaton has 20 states. Word has length 35 [2018-11-23 12:09:05,025 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:05,025 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 20 states. [2018-11-23 12:09:05,026 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 19 states to 19 states and 67 transitions. [2018-11-23 12:09:05,026 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 20 states. [2018-11-23 12:09:05,027 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 19 states to 19 states and 67 transitions. [2018-11-23 12:09:05,028 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 19 states and 67 transitions. [2018-11-23 12:09:05,118 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 67 edges. 67 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:05,119 INFO L225 Difference]: With dead ends: 65 [2018-11-23 12:09:05,119 INFO L226 Difference]: Without dead ends: 49 [2018-11-23 12:09:05,120 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:05,120 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 49 states. [2018-11-23 12:09:05,147 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 49 to 40. [2018-11-23 12:09:05,148 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:05,148 INFO L82 GeneralOperation]: Start isEquivalent. First operand 49 states. Second operand 40 states. [2018-11-23 12:09:05,148 INFO L74 IsIncluded]: Start isIncluded. First operand 49 states. Second operand 40 states. [2018-11-23 12:09:05,148 INFO L87 Difference]: Start difference. First operand 49 states. Second operand 40 states. [2018-11-23 12:09:05,150 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:05,150 INFO L93 Difference]: Finished difference Result 49 states and 54 transitions. [2018-11-23 12:09:05,150 INFO L276 IsEmpty]: Start isEmpty. Operand 49 states and 54 transitions. [2018-11-23 12:09:05,151 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:05,151 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:05,151 INFO L74 IsIncluded]: Start isIncluded. First operand 40 states. Second operand 49 states. [2018-11-23 12:09:05,151 INFO L87 Difference]: Start difference. First operand 40 states. Second operand 49 states. [2018-11-23 12:09:05,152 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:05,153 INFO L93 Difference]: Finished difference Result 49 states and 54 transitions. [2018-11-23 12:09:05,153 INFO L276 IsEmpty]: Start isEmpty. Operand 49 states and 54 transitions. [2018-11-23 12:09:05,153 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:05,153 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:05,153 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:05,153 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:05,154 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 40 states. [2018-11-23 12:09:05,155 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 40 states to 40 states and 42 transitions. [2018-11-23 12:09:05,155 INFO L78 Accepts]: Start accepts. Automaton has 40 states and 42 transitions. Word has length 35 [2018-11-23 12:09:05,155 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:05,155 INFO L480 AbstractCegarLoop]: Abstraction has 40 states and 42 transitions. [2018-11-23 12:09:05,155 INFO L481 AbstractCegarLoop]: Interpolant automaton has 20 states. [2018-11-23 12:09:05,155 INFO L276 IsEmpty]: Start isEmpty. Operand 40 states and 42 transitions. [2018-11-23 12:09:05,155 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 37 [2018-11-23 12:09:05,156 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:05,156 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:05,156 INFO L423 AbstractCegarLoop]: === Iteration 15 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:05,156 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:05,156 INFO L82 PathProgramCache]: Analyzing trace with hash 509039242, now seen corresponding path program 12 times [2018-11-23 12:09:05,156 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:05,157 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:05,157 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:05,157 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:05,157 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:05,173 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:05,840 INFO L256 TraceCheckUtils]: 0: Hoare triple {3680#true} call ULTIMATE.init(); {3680#true} is VALID [2018-11-23 12:09:05,841 INFO L273 TraceCheckUtils]: 1: Hoare triple {3680#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {3680#true} is VALID [2018-11-23 12:09:05,841 INFO L273 TraceCheckUtils]: 2: Hoare triple {3680#true} assume true; {3680#true} is VALID [2018-11-23 12:09:05,841 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3680#true} {3680#true} #60#return; {3680#true} is VALID [2018-11-23 12:09:05,842 INFO L256 TraceCheckUtils]: 4: Hoare triple {3680#true} call #t~ret4 := main(); {3680#true} is VALID [2018-11-23 12:09:05,842 INFO L273 TraceCheckUtils]: 5: Hoare triple {3680#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; {3682#(= main_~i~0 0)} is VALID [2018-11-23 12:09:05,843 INFO L273 TraceCheckUtils]: 6: Hoare triple {3682#(= 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; {3683#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:05,844 INFO L273 TraceCheckUtils]: 7: Hoare triple {3683#(<= 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; {3684#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:05,844 INFO L273 TraceCheckUtils]: 8: Hoare triple {3684#(<= 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; {3685#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:05,845 INFO L273 TraceCheckUtils]: 9: Hoare triple {3685#(<= 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; {3686#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:05,846 INFO L273 TraceCheckUtils]: 10: Hoare triple {3686#(<= 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; {3687#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:05,847 INFO L273 TraceCheckUtils]: 11: Hoare triple {3687#(<= 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; {3688#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:05,848 INFO L273 TraceCheckUtils]: 12: Hoare triple {3688#(<= 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; {3689#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:05,849 INFO L273 TraceCheckUtils]: 13: Hoare triple {3689#(<= 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; {3690#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:05,850 INFO L273 TraceCheckUtils]: 14: Hoare triple {3690#(<= 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; {3691#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:05,851 INFO L273 TraceCheckUtils]: 15: Hoare triple {3691#(<= 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; {3692#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:05,852 INFO L273 TraceCheckUtils]: 16: Hoare triple {3692#(<= 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; {3693#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:05,853 INFO L273 TraceCheckUtils]: 17: Hoare triple {3693#(<= 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; {3694#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:05,854 INFO L273 TraceCheckUtils]: 18: Hoare triple {3694#(<= 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; {3695#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:05,855 INFO L273 TraceCheckUtils]: 19: Hoare triple {3695#(<= 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; {3696#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:05,856 INFO L273 TraceCheckUtils]: 20: Hoare triple {3696#(<= 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; {3697#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:05,856 INFO L273 TraceCheckUtils]: 21: Hoare triple {3697#(<= 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; {3698#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:05,857 INFO L273 TraceCheckUtils]: 22: Hoare triple {3698#(<= 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; {3699#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:05,858 INFO L273 TraceCheckUtils]: 23: Hoare triple {3699#(<= main_~i~0 17)} assume !(~i~0 < 100000); {3681#false} is VALID [2018-11-23 12:09:05,858 INFO L273 TraceCheckUtils]: 24: Hoare triple {3681#false} ~i~0 := 1; {3681#false} is VALID [2018-11-23 12:09:05,859 INFO L273 TraceCheckUtils]: 25: Hoare triple {3681#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3681#false} is VALID [2018-11-23 12:09:05,859 INFO L273 TraceCheckUtils]: 26: Hoare triple {3681#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3681#false} is VALID [2018-11-23 12:09:05,859 INFO L273 TraceCheckUtils]: 27: Hoare triple {3681#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3681#false} is VALID [2018-11-23 12:09:05,859 INFO L273 TraceCheckUtils]: 28: Hoare triple {3681#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3681#false} is VALID [2018-11-23 12:09:05,859 INFO L273 TraceCheckUtils]: 29: Hoare triple {3681#false} assume !(~i~0 < 100000); {3681#false} is VALID [2018-11-23 12:09:05,860 INFO L273 TraceCheckUtils]: 30: Hoare triple {3681#false} ~i~0 := 1;~j~0 := 0; {3681#false} is VALID [2018-11-23 12:09:05,860 INFO L273 TraceCheckUtils]: 31: Hoare triple {3681#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 + 7 * ~j~0), 4); {3681#false} is VALID [2018-11-23 12:09:05,860 INFO L256 TraceCheckUtils]: 32: Hoare triple {3681#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {3681#false} is VALID [2018-11-23 12:09:05,860 INFO L273 TraceCheckUtils]: 33: Hoare triple {3681#false} ~cond := #in~cond; {3681#false} is VALID [2018-11-23 12:09:05,860 INFO L273 TraceCheckUtils]: 34: Hoare triple {3681#false} assume 0 == ~cond; {3681#false} is VALID [2018-11-23 12:09:05,861 INFO L273 TraceCheckUtils]: 35: Hoare triple {3681#false} assume !false; {3681#false} is VALID [2018-11-23 12:09:05,862 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:05,862 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:05,863 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:05,872 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE [2018-11-23 12:09:05,908 INFO L249 tOrderPrioritization]: Assert order MIX_INSIDE_OUTSIDE issued 5 check-sat command(s) [2018-11-23 12:09:05,908 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:05,917 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:05,919 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:06,007 INFO L256 TraceCheckUtils]: 0: Hoare triple {3680#true} call ULTIMATE.init(); {3680#true} is VALID [2018-11-23 12:09:06,008 INFO L273 TraceCheckUtils]: 1: Hoare triple {3680#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {3680#true} is VALID [2018-11-23 12:09:06,008 INFO L273 TraceCheckUtils]: 2: Hoare triple {3680#true} assume true; {3680#true} is VALID [2018-11-23 12:09:06,008 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3680#true} {3680#true} #60#return; {3680#true} is VALID [2018-11-23 12:09:06,008 INFO L256 TraceCheckUtils]: 4: Hoare triple {3680#true} call #t~ret4 := main(); {3680#true} is VALID [2018-11-23 12:09:06,009 INFO L273 TraceCheckUtils]: 5: Hoare triple {3680#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; {3680#true} is VALID [2018-11-23 12:09:06,009 INFO L273 TraceCheckUtils]: 6: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,009 INFO L273 TraceCheckUtils]: 7: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,010 INFO L273 TraceCheckUtils]: 8: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,010 INFO L273 TraceCheckUtils]: 9: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,010 INFO L273 TraceCheckUtils]: 10: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,010 INFO L273 TraceCheckUtils]: 11: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,010 INFO L273 TraceCheckUtils]: 12: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,010 INFO L273 TraceCheckUtils]: 13: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,010 INFO L273 TraceCheckUtils]: 14: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,011 INFO L273 TraceCheckUtils]: 15: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,011 INFO L273 TraceCheckUtils]: 16: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,011 INFO L273 TraceCheckUtils]: 17: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,011 INFO L273 TraceCheckUtils]: 18: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,011 INFO L273 TraceCheckUtils]: 19: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,011 INFO L273 TraceCheckUtils]: 20: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,012 INFO L273 TraceCheckUtils]: 21: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,012 INFO L273 TraceCheckUtils]: 22: Hoare triple {3680#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {3680#true} is VALID [2018-11-23 12:09:06,012 INFO L273 TraceCheckUtils]: 23: Hoare triple {3680#true} assume !(~i~0 < 100000); {3680#true} is VALID [2018-11-23 12:09:06,032 INFO L273 TraceCheckUtils]: 24: Hoare triple {3680#true} ~i~0 := 1; {3683#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:06,034 INFO L273 TraceCheckUtils]: 25: Hoare triple {3683#(<= 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3690#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:06,034 INFO L273 TraceCheckUtils]: 26: Hoare triple {3690#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3697#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:06,035 INFO L273 TraceCheckUtils]: 27: Hoare triple {3697#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3784#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:06,036 INFO L273 TraceCheckUtils]: 28: Hoare triple {3784#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {3788#(<= main_~i~0 29)} is VALID [2018-11-23 12:09:06,036 INFO L273 TraceCheckUtils]: 29: Hoare triple {3788#(<= main_~i~0 29)} assume !(~i~0 < 100000); {3681#false} is VALID [2018-11-23 12:09:06,036 INFO L273 TraceCheckUtils]: 30: Hoare triple {3681#false} ~i~0 := 1;~j~0 := 0; {3681#false} is VALID [2018-11-23 12:09:06,037 INFO L273 TraceCheckUtils]: 31: Hoare triple {3681#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 + 7 * ~j~0), 4); {3681#false} is VALID [2018-11-23 12:09:06,037 INFO L256 TraceCheckUtils]: 32: Hoare triple {3681#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {3681#false} is VALID [2018-11-23 12:09:06,037 INFO L273 TraceCheckUtils]: 33: Hoare triple {3681#false} ~cond := #in~cond; {3681#false} is VALID [2018-11-23 12:09:06,037 INFO L273 TraceCheckUtils]: 34: Hoare triple {3681#false} assume 0 == ~cond; {3681#false} is VALID [2018-11-23 12:09:06,037 INFO L273 TraceCheckUtils]: 35: Hoare triple {3681#false} assume !false; {3681#false} is VALID [2018-11-23 12:09:06,039 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:06,060 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:06,060 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [20, 7] total 22 [2018-11-23 12:09:06,060 INFO L78 Accepts]: Start accepts. Automaton has 22 states. Word has length 36 [2018-11-23 12:09:06,061 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:06,061 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 22 states. [2018-11-23 12:09:06,096 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:06,097 INFO L459 AbstractCegarLoop]: Interpolant automaton has 22 states [2018-11-23 12:09:06,097 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 22 interpolants. [2018-11-23 12:09:06,097 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=231, Invalid=231, Unknown=0, NotChecked=0, Total=462 [2018-11-23 12:09:06,098 INFO L87 Difference]: Start difference. First operand 40 states and 42 transitions. Second operand 22 states. [2018-11-23 12:09:06,701 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:06,701 INFO L93 Difference]: Finished difference Result 75 states and 87 transitions. [2018-11-23 12:09:06,701 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 22 states. [2018-11-23 12:09:06,701 INFO L78 Accepts]: Start accepts. Automaton has 22 states. Word has length 36 [2018-11-23 12:09:06,701 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:06,702 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 22 states. [2018-11-23 12:09:06,703 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 22 states to 22 states and 83 transitions. [2018-11-23 12:09:06,703 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 22 states. [2018-11-23 12:09:06,705 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 22 states to 22 states and 83 transitions. [2018-11-23 12:09:06,705 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 22 states and 83 transitions. [2018-11-23 12:09:06,784 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 83 edges. 83 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:06,786 INFO L225 Difference]: With dead ends: 75 [2018-11-23 12:09:06,786 INFO L226 Difference]: Without dead ends: 59 [2018-11-23 12:09:06,787 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 55 GetRequests, 35 SyntacticMatches, 0 SemanticMatches, 20 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.5s TimeCoverageRelationStatistics Valid=231, Invalid=231, Unknown=0, NotChecked=0, Total=462 [2018-11-23 12:09:06,787 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 59 states. [2018-11-23 12:09:06,814 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 59 to 44. [2018-11-23 12:09:06,814 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:06,814 INFO L82 GeneralOperation]: Start isEquivalent. First operand 59 states. Second operand 44 states. [2018-11-23 12:09:06,814 INFO L74 IsIncluded]: Start isIncluded. First operand 59 states. Second operand 44 states. [2018-11-23 12:09:06,815 INFO L87 Difference]: Start difference. First operand 59 states. Second operand 44 states. [2018-11-23 12:09:06,817 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:06,817 INFO L93 Difference]: Finished difference Result 59 states and 66 transitions. [2018-11-23 12:09:06,817 INFO L276 IsEmpty]: Start isEmpty. Operand 59 states and 66 transitions. [2018-11-23 12:09:06,817 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:06,818 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:06,818 INFO L74 IsIncluded]: Start isIncluded. First operand 44 states. Second operand 59 states. [2018-11-23 12:09:06,818 INFO L87 Difference]: Start difference. First operand 44 states. Second operand 59 states. [2018-11-23 12:09:06,820 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:06,820 INFO L93 Difference]: Finished difference Result 59 states and 66 transitions. [2018-11-23 12:09:06,820 INFO L276 IsEmpty]: Start isEmpty. Operand 59 states and 66 transitions. [2018-11-23 12:09:06,821 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:06,821 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:06,821 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:06,821 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:06,821 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 44 states. [2018-11-23 12:09:06,822 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 44 states to 44 states and 46 transitions. [2018-11-23 12:09:06,822 INFO L78 Accepts]: Start accepts. Automaton has 44 states and 46 transitions. Word has length 36 [2018-11-23 12:09:06,822 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:06,823 INFO L480 AbstractCegarLoop]: Abstraction has 44 states and 46 transitions. [2018-11-23 12:09:06,823 INFO L481 AbstractCegarLoop]: Interpolant automaton has 22 states. [2018-11-23 12:09:06,823 INFO L276 IsEmpty]: Start isEmpty. Operand 44 states and 46 transitions. [2018-11-23 12:09:06,823 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 41 [2018-11-23 12:09:06,823 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:06,823 INFO L402 BasicCegarLoop]: trace histogram [20, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:06,824 INFO L423 AbstractCegarLoop]: === Iteration 16 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:06,824 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:06,824 INFO L82 PathProgramCache]: Analyzing trace with hash -463835735, now seen corresponding path program 13 times [2018-11-23 12:09:06,824 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:06,824 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:06,825 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:06,825 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:06,825 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:06,844 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:08,040 INFO L256 TraceCheckUtils]: 0: Hoare triple {4132#true} call ULTIMATE.init(); {4132#true} is VALID [2018-11-23 12:09:08,040 INFO L273 TraceCheckUtils]: 1: Hoare triple {4132#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {4132#true} is VALID [2018-11-23 12:09:08,040 INFO L273 TraceCheckUtils]: 2: Hoare triple {4132#true} assume true; {4132#true} is VALID [2018-11-23 12:09:08,041 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {4132#true} {4132#true} #60#return; {4132#true} is VALID [2018-11-23 12:09:08,041 INFO L256 TraceCheckUtils]: 4: Hoare triple {4132#true} call #t~ret4 := main(); {4132#true} is VALID [2018-11-23 12:09:08,041 INFO L273 TraceCheckUtils]: 5: Hoare triple {4132#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; {4134#(= main_~i~0 0)} is VALID [2018-11-23 12:09:08,042 INFO L273 TraceCheckUtils]: 6: Hoare triple {4134#(= 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; {4135#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:08,043 INFO L273 TraceCheckUtils]: 7: Hoare triple {4135#(<= 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; {4136#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:08,044 INFO L273 TraceCheckUtils]: 8: Hoare triple {4136#(<= 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; {4137#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:08,044 INFO L273 TraceCheckUtils]: 9: Hoare triple {4137#(<= 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; {4138#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:08,045 INFO L273 TraceCheckUtils]: 10: Hoare triple {4138#(<= 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; {4139#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:08,046 INFO L273 TraceCheckUtils]: 11: Hoare triple {4139#(<= 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; {4140#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:08,047 INFO L273 TraceCheckUtils]: 12: Hoare triple {4140#(<= 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; {4141#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:08,048 INFO L273 TraceCheckUtils]: 13: Hoare triple {4141#(<= 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; {4142#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:08,049 INFO L273 TraceCheckUtils]: 14: Hoare triple {4142#(<= 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; {4143#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:08,050 INFO L273 TraceCheckUtils]: 15: Hoare triple {4143#(<= 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; {4144#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:08,051 INFO L273 TraceCheckUtils]: 16: Hoare triple {4144#(<= 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; {4145#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:08,052 INFO L273 TraceCheckUtils]: 17: Hoare triple {4145#(<= 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; {4146#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:08,053 INFO L273 TraceCheckUtils]: 18: Hoare triple {4146#(<= 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; {4147#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:08,054 INFO L273 TraceCheckUtils]: 19: Hoare triple {4147#(<= 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; {4148#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:08,055 INFO L273 TraceCheckUtils]: 20: Hoare triple {4148#(<= 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; {4149#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:08,056 INFO L273 TraceCheckUtils]: 21: Hoare triple {4149#(<= 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; {4150#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:08,057 INFO L273 TraceCheckUtils]: 22: Hoare triple {4150#(<= 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; {4151#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:08,058 INFO L273 TraceCheckUtils]: 23: Hoare triple {4151#(<= 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; {4152#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:08,059 INFO L273 TraceCheckUtils]: 24: Hoare triple {4152#(<= 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; {4153#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:08,060 INFO L273 TraceCheckUtils]: 25: Hoare triple {4153#(<= 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; {4154#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:08,061 INFO L273 TraceCheckUtils]: 26: Hoare triple {4154#(<= main_~i~0 20)} assume !(~i~0 < 100000); {4133#false} is VALID [2018-11-23 12:09:08,061 INFO L273 TraceCheckUtils]: 27: Hoare triple {4133#false} ~i~0 := 1; {4133#false} is VALID [2018-11-23 12:09:08,061 INFO L273 TraceCheckUtils]: 28: Hoare triple {4133#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4133#false} is VALID [2018-11-23 12:09:08,061 INFO L273 TraceCheckUtils]: 29: Hoare triple {4133#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4133#false} is VALID [2018-11-23 12:09:08,061 INFO L273 TraceCheckUtils]: 30: Hoare triple {4133#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4133#false} is VALID [2018-11-23 12:09:08,062 INFO L273 TraceCheckUtils]: 31: Hoare triple {4133#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4133#false} is VALID [2018-11-23 12:09:08,062 INFO L273 TraceCheckUtils]: 32: Hoare triple {4133#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4133#false} is VALID [2018-11-23 12:09:08,062 INFO L273 TraceCheckUtils]: 33: Hoare triple {4133#false} assume !(~i~0 < 100000); {4133#false} is VALID [2018-11-23 12:09:08,062 INFO L273 TraceCheckUtils]: 34: Hoare triple {4133#false} ~i~0 := 1;~j~0 := 0; {4133#false} is VALID [2018-11-23 12:09:08,063 INFO L273 TraceCheckUtils]: 35: Hoare triple {4133#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 + 7 * ~j~0), 4); {4133#false} is VALID [2018-11-23 12:09:08,063 INFO L256 TraceCheckUtils]: 36: Hoare triple {4133#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {4133#false} is VALID [2018-11-23 12:09:08,063 INFO L273 TraceCheckUtils]: 37: Hoare triple {4133#false} ~cond := #in~cond; {4133#false} is VALID [2018-11-23 12:09:08,063 INFO L273 TraceCheckUtils]: 38: Hoare triple {4133#false} assume 0 == ~cond; {4133#false} is VALID [2018-11-23 12:09:08,063 INFO L273 TraceCheckUtils]: 39: Hoare triple {4133#false} assume !false; {4133#false} is VALID [2018-11-23 12:09:08,065 INFO L134 CoverageAnalysis]: Checked inductivity of 225 backedges. 0 proven. 210 refuted. 0 times theorem prover too weak. 15 trivial. 0 not checked. [2018-11-23 12:09:08,065 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:08,065 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:08,073 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:08,106 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:08,137 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:08,138 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:08,279 INFO L256 TraceCheckUtils]: 0: Hoare triple {4132#true} call ULTIMATE.init(); {4132#true} is VALID [2018-11-23 12:09:08,279 INFO L273 TraceCheckUtils]: 1: Hoare triple {4132#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {4132#true} is VALID [2018-11-23 12:09:08,280 INFO L273 TraceCheckUtils]: 2: Hoare triple {4132#true} assume true; {4132#true} is VALID [2018-11-23 12:09:08,280 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {4132#true} {4132#true} #60#return; {4132#true} is VALID [2018-11-23 12:09:08,280 INFO L256 TraceCheckUtils]: 4: Hoare triple {4132#true} call #t~ret4 := main(); {4132#true} is VALID [2018-11-23 12:09:08,281 INFO L273 TraceCheckUtils]: 5: Hoare triple {4132#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; {4173#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:08,282 INFO L273 TraceCheckUtils]: 6: Hoare triple {4173#(<= 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; {4135#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:08,283 INFO L273 TraceCheckUtils]: 7: Hoare triple {4135#(<= 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; {4136#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:08,283 INFO L273 TraceCheckUtils]: 8: Hoare triple {4136#(<= 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; {4137#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:08,284 INFO L273 TraceCheckUtils]: 9: Hoare triple {4137#(<= 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; {4138#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:08,284 INFO L273 TraceCheckUtils]: 10: Hoare triple {4138#(<= 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; {4139#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:08,285 INFO L273 TraceCheckUtils]: 11: Hoare triple {4139#(<= 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; {4140#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:08,286 INFO L273 TraceCheckUtils]: 12: Hoare triple {4140#(<= 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; {4141#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:08,287 INFO L273 TraceCheckUtils]: 13: Hoare triple {4141#(<= 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; {4142#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:08,288 INFO L273 TraceCheckUtils]: 14: Hoare triple {4142#(<= 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; {4143#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:08,289 INFO L273 TraceCheckUtils]: 15: Hoare triple {4143#(<= 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; {4144#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:08,290 INFO L273 TraceCheckUtils]: 16: Hoare triple {4144#(<= 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; {4145#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:08,291 INFO L273 TraceCheckUtils]: 17: Hoare triple {4145#(<= 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; {4146#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:08,292 INFO L273 TraceCheckUtils]: 18: Hoare triple {4146#(<= 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; {4147#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:08,293 INFO L273 TraceCheckUtils]: 19: Hoare triple {4147#(<= 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; {4148#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:08,294 INFO L273 TraceCheckUtils]: 20: Hoare triple {4148#(<= 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; {4149#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:08,295 INFO L273 TraceCheckUtils]: 21: Hoare triple {4149#(<= 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; {4150#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:08,296 INFO L273 TraceCheckUtils]: 22: Hoare triple {4150#(<= 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; {4151#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:08,297 INFO L273 TraceCheckUtils]: 23: Hoare triple {4151#(<= 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; {4152#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:08,298 INFO L273 TraceCheckUtils]: 24: Hoare triple {4152#(<= 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; {4153#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:08,299 INFO L273 TraceCheckUtils]: 25: Hoare triple {4153#(<= 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; {4154#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:08,299 INFO L273 TraceCheckUtils]: 26: Hoare triple {4154#(<= main_~i~0 20)} assume !(~i~0 < 100000); {4133#false} is VALID [2018-11-23 12:09:08,300 INFO L273 TraceCheckUtils]: 27: Hoare triple {4133#false} ~i~0 := 1; {4133#false} is VALID [2018-11-23 12:09:08,300 INFO L273 TraceCheckUtils]: 28: Hoare triple {4133#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4133#false} is VALID [2018-11-23 12:09:08,300 INFO L273 TraceCheckUtils]: 29: Hoare triple {4133#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4133#false} is VALID [2018-11-23 12:09:08,300 INFO L273 TraceCheckUtils]: 30: Hoare triple {4133#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4133#false} is VALID [2018-11-23 12:09:08,300 INFO L273 TraceCheckUtils]: 31: Hoare triple {4133#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4133#false} is VALID [2018-11-23 12:09:08,301 INFO L273 TraceCheckUtils]: 32: Hoare triple {4133#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4133#false} is VALID [2018-11-23 12:09:08,301 INFO L273 TraceCheckUtils]: 33: Hoare triple {4133#false} assume !(~i~0 < 100000); {4133#false} is VALID [2018-11-23 12:09:08,301 INFO L273 TraceCheckUtils]: 34: Hoare triple {4133#false} ~i~0 := 1;~j~0 := 0; {4133#false} is VALID [2018-11-23 12:09:08,301 INFO L273 TraceCheckUtils]: 35: Hoare triple {4133#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 + 7 * ~j~0), 4); {4133#false} is VALID [2018-11-23 12:09:08,302 INFO L256 TraceCheckUtils]: 36: Hoare triple {4133#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {4133#false} is VALID [2018-11-23 12:09:08,302 INFO L273 TraceCheckUtils]: 37: Hoare triple {4133#false} ~cond := #in~cond; {4133#false} is VALID [2018-11-23 12:09:08,302 INFO L273 TraceCheckUtils]: 38: Hoare triple {4133#false} assume 0 == ~cond; {4133#false} is VALID [2018-11-23 12:09:08,302 INFO L273 TraceCheckUtils]: 39: Hoare triple {4133#false} assume !false; {4133#false} is VALID [2018-11-23 12:09:08,303 INFO L134 CoverageAnalysis]: Checked inductivity of 225 backedges. 0 proven. 210 refuted. 0 times theorem prover too weak. 15 trivial. 0 not checked. [2018-11-23 12:09:08,321 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:08,321 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [23, 23] total 24 [2018-11-23 12:09:08,322 INFO L78 Accepts]: Start accepts. Automaton has 24 states. Word has length 40 [2018-11-23 12:09:08,322 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:08,322 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 24 states. [2018-11-23 12:09:08,352 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 38 edges. 38 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:08,352 INFO L459 AbstractCegarLoop]: Interpolant automaton has 24 states [2018-11-23 12:09:08,353 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 24 interpolants. [2018-11-23 12:09:08,353 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=276, Invalid=276, Unknown=0, NotChecked=0, Total=552 [2018-11-23 12:09:08,353 INFO L87 Difference]: Start difference. First operand 44 states and 46 transitions. Second operand 24 states. [2018-11-23 12:09:09,279 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:09,280 INFO L93 Difference]: Finished difference Result 71 states and 78 transitions. [2018-11-23 12:09:09,280 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 23 states. [2018-11-23 12:09:09,280 INFO L78 Accepts]: Start accepts. Automaton has 24 states. Word has length 40 [2018-11-23 12:09:09,281 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:09,281 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 24 states. [2018-11-23 12:09:09,282 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 23 states to 23 states and 71 transitions. [2018-11-23 12:09:09,282 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 24 states. [2018-11-23 12:09:09,284 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 23 states to 23 states and 71 transitions. [2018-11-23 12:09:09,284 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 23 states and 71 transitions. [2018-11-23 12:09:09,390 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 71 edges. 71 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:09,391 INFO L225 Difference]: With dead ends: 71 [2018-11-23 12:09:09,392 INFO L226 Difference]: Without dead ends: 54 [2018-11-23 12:09:09,393 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 62 GetRequests, 40 SyntacticMatches, 0 SemanticMatches, 22 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 38 ImplicationChecksByTransitivity, 0.9s TimeCoverageRelationStatistics Valid=276, Invalid=276, Unknown=0, NotChecked=0, Total=552 [2018-11-23 12:09:09,393 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 54 states. [2018-11-23 12:09:09,428 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 54 to 45. [2018-11-23 12:09:09,428 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:09,428 INFO L82 GeneralOperation]: Start isEquivalent. First operand 54 states. Second operand 45 states. [2018-11-23 12:09:09,428 INFO L74 IsIncluded]: Start isIncluded. First operand 54 states. Second operand 45 states. [2018-11-23 12:09:09,429 INFO L87 Difference]: Start difference. First operand 54 states. Second operand 45 states. [2018-11-23 12:09:09,430 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:09,430 INFO L93 Difference]: Finished difference Result 54 states and 59 transitions. [2018-11-23 12:09:09,430 INFO L276 IsEmpty]: Start isEmpty. Operand 54 states and 59 transitions. [2018-11-23 12:09:09,430 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:09,430 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:09,430 INFO L74 IsIncluded]: Start isIncluded. First operand 45 states. Second operand 54 states. [2018-11-23 12:09:09,431 INFO L87 Difference]: Start difference. First operand 45 states. Second operand 54 states. [2018-11-23 12:09:09,432 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:09,432 INFO L93 Difference]: Finished difference Result 54 states and 59 transitions. [2018-11-23 12:09:09,432 INFO L276 IsEmpty]: Start isEmpty. Operand 54 states and 59 transitions. [2018-11-23 12:09:09,432 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:09,432 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:09,432 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:09,433 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:09,433 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 45 states. [2018-11-23 12:09:09,434 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 45 states to 45 states and 47 transitions. [2018-11-23 12:09:09,434 INFO L78 Accepts]: Start accepts. Automaton has 45 states and 47 transitions. Word has length 40 [2018-11-23 12:09:09,434 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:09,434 INFO L480 AbstractCegarLoop]: Abstraction has 45 states and 47 transitions. [2018-11-23 12:09:09,434 INFO L481 AbstractCegarLoop]: Interpolant automaton has 24 states. [2018-11-23 12:09:09,434 INFO L276 IsEmpty]: Start isEmpty. Operand 45 states and 47 transitions. [2018-11-23 12:09:09,435 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 42 [2018-11-23 12:09:09,435 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:09,435 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:09,435 INFO L423 AbstractCegarLoop]: === Iteration 17 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:09,435 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:09,436 INFO L82 PathProgramCache]: Analyzing trace with hash 782248453, now seen corresponding path program 14 times [2018-11-23 12:09:09,436 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:09,436 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:09,437 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:09,437 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:09,437 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:09,454 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:09,825 INFO L256 TraceCheckUtils]: 0: Hoare triple {4584#true} call ULTIMATE.init(); {4584#true} is VALID [2018-11-23 12:09:09,825 INFO L273 TraceCheckUtils]: 1: Hoare triple {4584#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {4584#true} is VALID [2018-11-23 12:09:09,825 INFO L273 TraceCheckUtils]: 2: Hoare triple {4584#true} assume true; {4584#true} is VALID [2018-11-23 12:09:09,826 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {4584#true} {4584#true} #60#return; {4584#true} is VALID [2018-11-23 12:09:09,826 INFO L256 TraceCheckUtils]: 4: Hoare triple {4584#true} call #t~ret4 := main(); {4584#true} is VALID [2018-11-23 12:09:09,826 INFO L273 TraceCheckUtils]: 5: Hoare triple {4584#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; {4586#(= main_~i~0 0)} is VALID [2018-11-23 12:09:09,827 INFO L273 TraceCheckUtils]: 6: Hoare triple {4586#(= 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; {4587#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:09,828 INFO L273 TraceCheckUtils]: 7: Hoare triple {4587#(<= 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; {4588#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:09,829 INFO L273 TraceCheckUtils]: 8: Hoare triple {4588#(<= 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; {4589#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:09,830 INFO L273 TraceCheckUtils]: 9: Hoare triple {4589#(<= 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; {4590#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:09,831 INFO L273 TraceCheckUtils]: 10: Hoare triple {4590#(<= 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; {4591#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:09,832 INFO L273 TraceCheckUtils]: 11: Hoare triple {4591#(<= 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; {4592#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:09,833 INFO L273 TraceCheckUtils]: 12: Hoare triple {4592#(<= 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; {4593#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:09,834 INFO L273 TraceCheckUtils]: 13: Hoare triple {4593#(<= 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; {4594#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:09,835 INFO L273 TraceCheckUtils]: 14: Hoare triple {4594#(<= 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; {4595#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:09,836 INFO L273 TraceCheckUtils]: 15: Hoare triple {4595#(<= 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; {4596#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:09,837 INFO L273 TraceCheckUtils]: 16: Hoare triple {4596#(<= 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; {4597#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:09,838 INFO L273 TraceCheckUtils]: 17: Hoare triple {4597#(<= 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; {4598#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:09,839 INFO L273 TraceCheckUtils]: 18: Hoare triple {4598#(<= 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; {4599#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:09,840 INFO L273 TraceCheckUtils]: 19: Hoare triple {4599#(<= 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; {4600#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:09,841 INFO L273 TraceCheckUtils]: 20: Hoare triple {4600#(<= 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; {4601#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:09,860 INFO L273 TraceCheckUtils]: 21: Hoare triple {4601#(<= 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; {4602#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:09,873 INFO L273 TraceCheckUtils]: 22: Hoare triple {4602#(<= 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; {4603#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:09,882 INFO L273 TraceCheckUtils]: 23: Hoare triple {4603#(<= 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; {4604#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:09,897 INFO L273 TraceCheckUtils]: 24: Hoare triple {4604#(<= 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; {4605#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:09,912 INFO L273 TraceCheckUtils]: 25: Hoare triple {4605#(<= 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; {4606#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:09,926 INFO L273 TraceCheckUtils]: 26: Hoare triple {4606#(<= 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; {4607#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:09,935 INFO L273 TraceCheckUtils]: 27: Hoare triple {4607#(<= main_~i~0 21)} assume !(~i~0 < 100000); {4585#false} is VALID [2018-11-23 12:09:09,935 INFO L273 TraceCheckUtils]: 28: Hoare triple {4585#false} ~i~0 := 1; {4585#false} is VALID [2018-11-23 12:09:09,935 INFO L273 TraceCheckUtils]: 29: Hoare triple {4585#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4585#false} is VALID [2018-11-23 12:09:09,936 INFO L273 TraceCheckUtils]: 30: Hoare triple {4585#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4585#false} is VALID [2018-11-23 12:09:09,936 INFO L273 TraceCheckUtils]: 31: Hoare triple {4585#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4585#false} is VALID [2018-11-23 12:09:09,936 INFO L273 TraceCheckUtils]: 32: Hoare triple {4585#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4585#false} is VALID [2018-11-23 12:09:09,936 INFO L273 TraceCheckUtils]: 33: Hoare triple {4585#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4585#false} is VALID [2018-11-23 12:09:09,936 INFO L273 TraceCheckUtils]: 34: Hoare triple {4585#false} assume !(~i~0 < 100000); {4585#false} is VALID [2018-11-23 12:09:09,936 INFO L273 TraceCheckUtils]: 35: Hoare triple {4585#false} ~i~0 := 1;~j~0 := 0; {4585#false} is VALID [2018-11-23 12:09:09,937 INFO L273 TraceCheckUtils]: 36: Hoare triple {4585#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 + 7 * ~j~0), 4); {4585#false} is VALID [2018-11-23 12:09:09,937 INFO L256 TraceCheckUtils]: 37: Hoare triple {4585#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {4585#false} is VALID [2018-11-23 12:09:09,937 INFO L273 TraceCheckUtils]: 38: Hoare triple {4585#false} ~cond := #in~cond; {4585#false} is VALID [2018-11-23 12:09:09,937 INFO L273 TraceCheckUtils]: 39: Hoare triple {4585#false} assume 0 == ~cond; {4585#false} is VALID [2018-11-23 12:09:09,937 INFO L273 TraceCheckUtils]: 40: Hoare triple {4585#false} assume !false; {4585#false} is VALID [2018-11-23 12:09:09,939 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:09,939 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:09,939 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:09,955 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:09:09,988 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:09:09,989 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:10,012 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:10,014 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:10,177 INFO L256 TraceCheckUtils]: 0: Hoare triple {4584#true} call ULTIMATE.init(); {4584#true} is VALID [2018-11-23 12:09:10,178 INFO L273 TraceCheckUtils]: 1: Hoare triple {4584#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {4584#true} is VALID [2018-11-23 12:09:10,178 INFO L273 TraceCheckUtils]: 2: Hoare triple {4584#true} assume true; {4584#true} is VALID [2018-11-23 12:09:10,178 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {4584#true} {4584#true} #60#return; {4584#true} is VALID [2018-11-23 12:09:10,178 INFO L256 TraceCheckUtils]: 4: Hoare triple {4584#true} call #t~ret4 := main(); {4584#true} is VALID [2018-11-23 12:09:10,179 INFO L273 TraceCheckUtils]: 5: Hoare triple {4584#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; {4626#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:10,180 INFO L273 TraceCheckUtils]: 6: Hoare triple {4626#(<= 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; {4587#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:10,181 INFO L273 TraceCheckUtils]: 7: Hoare triple {4587#(<= 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; {4588#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:10,181 INFO L273 TraceCheckUtils]: 8: Hoare triple {4588#(<= 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; {4589#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:10,182 INFO L273 TraceCheckUtils]: 9: Hoare triple {4589#(<= 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; {4590#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:10,182 INFO L273 TraceCheckUtils]: 10: Hoare triple {4590#(<= 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; {4591#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:10,183 INFO L273 TraceCheckUtils]: 11: Hoare triple {4591#(<= 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; {4592#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:10,184 INFO L273 TraceCheckUtils]: 12: Hoare triple {4592#(<= 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; {4593#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:10,185 INFO L273 TraceCheckUtils]: 13: Hoare triple {4593#(<= 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; {4594#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:10,189 INFO L273 TraceCheckUtils]: 14: Hoare triple {4594#(<= 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; {4595#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:10,190 INFO L273 TraceCheckUtils]: 15: Hoare triple {4595#(<= 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; {4596#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:10,190 INFO L273 TraceCheckUtils]: 16: Hoare triple {4596#(<= 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; {4597#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:10,191 INFO L273 TraceCheckUtils]: 17: Hoare triple {4597#(<= 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; {4598#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:10,191 INFO L273 TraceCheckUtils]: 18: Hoare triple {4598#(<= 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; {4599#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:10,192 INFO L273 TraceCheckUtils]: 19: Hoare triple {4599#(<= 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; {4600#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:10,193 INFO L273 TraceCheckUtils]: 20: Hoare triple {4600#(<= 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; {4601#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:10,194 INFO L273 TraceCheckUtils]: 21: Hoare triple {4601#(<= 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; {4602#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:10,195 INFO L273 TraceCheckUtils]: 22: Hoare triple {4602#(<= 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; {4603#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:10,195 INFO L273 TraceCheckUtils]: 23: Hoare triple {4603#(<= 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; {4604#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:10,196 INFO L273 TraceCheckUtils]: 24: Hoare triple {4604#(<= 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; {4605#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:10,197 INFO L273 TraceCheckUtils]: 25: Hoare triple {4605#(<= 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; {4606#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:10,198 INFO L273 TraceCheckUtils]: 26: Hoare triple {4606#(<= 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; {4607#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:10,199 INFO L273 TraceCheckUtils]: 27: Hoare triple {4607#(<= main_~i~0 21)} assume !(~i~0 < 100000); {4585#false} is VALID [2018-11-23 12:09:10,199 INFO L273 TraceCheckUtils]: 28: Hoare triple {4585#false} ~i~0 := 1; {4585#false} is VALID [2018-11-23 12:09:10,199 INFO L273 TraceCheckUtils]: 29: Hoare triple {4585#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4585#false} is VALID [2018-11-23 12:09:10,200 INFO L273 TraceCheckUtils]: 30: Hoare triple {4585#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4585#false} is VALID [2018-11-23 12:09:10,200 INFO L273 TraceCheckUtils]: 31: Hoare triple {4585#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4585#false} is VALID [2018-11-23 12:09:10,200 INFO L273 TraceCheckUtils]: 32: Hoare triple {4585#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4585#false} is VALID [2018-11-23 12:09:10,200 INFO L273 TraceCheckUtils]: 33: Hoare triple {4585#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {4585#false} is VALID [2018-11-23 12:09:10,200 INFO L273 TraceCheckUtils]: 34: Hoare triple {4585#false} assume !(~i~0 < 100000); {4585#false} is VALID [2018-11-23 12:09:10,201 INFO L273 TraceCheckUtils]: 35: Hoare triple {4585#false} ~i~0 := 1;~j~0 := 0; {4585#false} is VALID [2018-11-23 12:09:10,201 INFO L273 TraceCheckUtils]: 36: Hoare triple {4585#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 + 7 * ~j~0), 4); {4585#false} is VALID [2018-11-23 12:09:10,201 INFO L256 TraceCheckUtils]: 37: Hoare triple {4585#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {4585#false} is VALID [2018-11-23 12:09:10,201 INFO L273 TraceCheckUtils]: 38: Hoare triple {4585#false} ~cond := #in~cond; {4585#false} is VALID [2018-11-23 12:09:10,201 INFO L273 TraceCheckUtils]: 39: Hoare triple {4585#false} assume 0 == ~cond; {4585#false} is VALID [2018-11-23 12:09:10,201 INFO L273 TraceCheckUtils]: 40: Hoare triple {4585#false} assume !false; {4585#false} is VALID [2018-11-23 12:09:10,203 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:10,221 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:10,221 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [24, 24] total 25 [2018-11-23 12:09:10,221 INFO L78 Accepts]: Start accepts. Automaton has 25 states. Word has length 41 [2018-11-23 12:09:10,222 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:10,222 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 25 states. [2018-11-23 12:09:10,252 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:10,252 INFO L459 AbstractCegarLoop]: Interpolant automaton has 25 states [2018-11-23 12:09:10,253 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 25 interpolants. [2018-11-23 12:09:10,253 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=300, Invalid=300, Unknown=0, NotChecked=0, Total=600 [2018-11-23 12:09:10,254 INFO L87 Difference]: Start difference. First operand 45 states and 47 transitions. Second operand 25 states. [2018-11-23 12:09:10,912 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:10,912 INFO L93 Difference]: Finished difference Result 72 states and 79 transitions. [2018-11-23 12:09:10,912 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 24 states. [2018-11-23 12:09:10,912 INFO L78 Accepts]: Start accepts. Automaton has 25 states. Word has length 41 [2018-11-23 12:09:10,913 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:10,913 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 25 states. [2018-11-23 12:09:10,914 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 24 states to 24 states and 72 transitions. [2018-11-23 12:09:10,915 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 25 states. [2018-11-23 12:09:10,916 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 24 states to 24 states and 72 transitions. [2018-11-23 12:09:10,916 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 24 states and 72 transitions. [2018-11-23 12:09:11,821 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:11,823 INFO L225 Difference]: With dead ends: 72 [2018-11-23 12:09:11,823 INFO L226 Difference]: Without dead ends: 55 [2018-11-23 12:09:11,824 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 64 GetRequests, 41 SyntacticMatches, 0 SemanticMatches, 23 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 40 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=300, Invalid=300, Unknown=0, NotChecked=0, Total=600 [2018-11-23 12:09:11,824 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 55 states. [2018-11-23 12:09:11,878 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 55 to 46. [2018-11-23 12:09:11,879 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:11,879 INFO L82 GeneralOperation]: Start isEquivalent. First operand 55 states. Second operand 46 states. [2018-11-23 12:09:11,879 INFO L74 IsIncluded]: Start isIncluded. First operand 55 states. Second operand 46 states. [2018-11-23 12:09:11,879 INFO L87 Difference]: Start difference. First operand 55 states. Second operand 46 states. [2018-11-23 12:09:11,882 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:11,882 INFO L93 Difference]: Finished difference Result 55 states and 60 transitions. [2018-11-23 12:09:11,882 INFO L276 IsEmpty]: Start isEmpty. Operand 55 states and 60 transitions. [2018-11-23 12:09:11,882 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:11,883 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:11,883 INFO L74 IsIncluded]: Start isIncluded. First operand 46 states. Second operand 55 states. [2018-11-23 12:09:11,883 INFO L87 Difference]: Start difference. First operand 46 states. Second operand 55 states. [2018-11-23 12:09:11,885 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:11,885 INFO L93 Difference]: Finished difference Result 55 states and 60 transitions. [2018-11-23 12:09:11,885 INFO L276 IsEmpty]: Start isEmpty. Operand 55 states and 60 transitions. [2018-11-23 12:09:11,886 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:11,886 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:11,886 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:11,886 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:11,886 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 46 states. [2018-11-23 12:09:11,887 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 46 states to 46 states and 48 transitions. [2018-11-23 12:09:11,888 INFO L78 Accepts]: Start accepts. Automaton has 46 states and 48 transitions. Word has length 41 [2018-11-23 12:09:11,888 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:11,888 INFO L480 AbstractCegarLoop]: Abstraction has 46 states and 48 transitions. [2018-11-23 12:09:11,888 INFO L481 AbstractCegarLoop]: Interpolant automaton has 25 states. [2018-11-23 12:09:11,888 INFO L276 IsEmpty]: Start isEmpty. Operand 46 states and 48 transitions. [2018-11-23 12:09:11,889 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 43 [2018-11-23 12:09:11,889 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:11,889 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:11,889 INFO L423 AbstractCegarLoop]: === Iteration 18 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:11,889 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:11,890 INFO L82 PathProgramCache]: Analyzing trace with hash 756152617, now seen corresponding path program 15 times [2018-11-23 12:09:11,890 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:11,890 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:11,891 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:11,891 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:11,891 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:11,911 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:13,191 INFO L256 TraceCheckUtils]: 0: Hoare triple {5046#true} call ULTIMATE.init(); {5046#true} is VALID [2018-11-23 12:09:13,191 INFO L273 TraceCheckUtils]: 1: Hoare triple {5046#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {5046#true} is VALID [2018-11-23 12:09:13,192 INFO L273 TraceCheckUtils]: 2: Hoare triple {5046#true} assume true; {5046#true} is VALID [2018-11-23 12:09:13,192 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {5046#true} {5046#true} #60#return; {5046#true} is VALID [2018-11-23 12:09:13,192 INFO L256 TraceCheckUtils]: 4: Hoare triple {5046#true} call #t~ret4 := main(); {5046#true} is VALID [2018-11-23 12:09:13,192 INFO L273 TraceCheckUtils]: 5: Hoare triple {5046#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; {5048#(= main_~i~0 0)} is VALID [2018-11-23 12:09:13,193 INFO L273 TraceCheckUtils]: 6: Hoare triple {5048#(= 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; {5049#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:13,194 INFO L273 TraceCheckUtils]: 7: Hoare triple {5049#(<= 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; {5050#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:13,195 INFO L273 TraceCheckUtils]: 8: Hoare triple {5050#(<= 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; {5051#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:13,196 INFO L273 TraceCheckUtils]: 9: Hoare triple {5051#(<= 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; {5052#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:13,197 INFO L273 TraceCheckUtils]: 10: Hoare triple {5052#(<= 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; {5053#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:13,198 INFO L273 TraceCheckUtils]: 11: Hoare triple {5053#(<= 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; {5054#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:13,199 INFO L273 TraceCheckUtils]: 12: Hoare triple {5054#(<= 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; {5055#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:13,200 INFO L273 TraceCheckUtils]: 13: Hoare triple {5055#(<= 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; {5056#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:13,201 INFO L273 TraceCheckUtils]: 14: Hoare triple {5056#(<= 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; {5057#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:13,202 INFO L273 TraceCheckUtils]: 15: Hoare triple {5057#(<= 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; {5058#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:13,203 INFO L273 TraceCheckUtils]: 16: Hoare triple {5058#(<= 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; {5059#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:13,204 INFO L273 TraceCheckUtils]: 17: Hoare triple {5059#(<= 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; {5060#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:13,205 INFO L273 TraceCheckUtils]: 18: Hoare triple {5060#(<= 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; {5061#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:13,206 INFO L273 TraceCheckUtils]: 19: Hoare triple {5061#(<= 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; {5062#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:13,207 INFO L273 TraceCheckUtils]: 20: Hoare triple {5062#(<= 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; {5063#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:13,208 INFO L273 TraceCheckUtils]: 21: Hoare triple {5063#(<= 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; {5064#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:13,209 INFO L273 TraceCheckUtils]: 22: Hoare triple {5064#(<= 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; {5065#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:13,210 INFO L273 TraceCheckUtils]: 23: Hoare triple {5065#(<= 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; {5066#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:13,210 INFO L273 TraceCheckUtils]: 24: Hoare triple {5066#(<= 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; {5067#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:13,211 INFO L273 TraceCheckUtils]: 25: Hoare triple {5067#(<= 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; {5068#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:13,212 INFO L273 TraceCheckUtils]: 26: Hoare triple {5068#(<= 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; {5069#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:13,213 INFO L273 TraceCheckUtils]: 27: Hoare triple {5069#(<= 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; {5070#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:13,214 INFO L273 TraceCheckUtils]: 28: Hoare triple {5070#(<= main_~i~0 22)} assume !(~i~0 < 100000); {5047#false} is VALID [2018-11-23 12:09:13,214 INFO L273 TraceCheckUtils]: 29: Hoare triple {5047#false} ~i~0 := 1; {5047#false} is VALID [2018-11-23 12:09:13,214 INFO L273 TraceCheckUtils]: 30: Hoare triple {5047#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5047#false} is VALID [2018-11-23 12:09:13,215 INFO L273 TraceCheckUtils]: 31: Hoare triple {5047#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5047#false} is VALID [2018-11-23 12:09:13,215 INFO L273 TraceCheckUtils]: 32: Hoare triple {5047#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5047#false} is VALID [2018-11-23 12:09:13,215 INFO L273 TraceCheckUtils]: 33: Hoare triple {5047#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5047#false} is VALID [2018-11-23 12:09:13,215 INFO L273 TraceCheckUtils]: 34: Hoare triple {5047#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5047#false} is VALID [2018-11-23 12:09:13,215 INFO L273 TraceCheckUtils]: 35: Hoare triple {5047#false} assume !(~i~0 < 100000); {5047#false} is VALID [2018-11-23 12:09:13,216 INFO L273 TraceCheckUtils]: 36: Hoare triple {5047#false} ~i~0 := 1;~j~0 := 0; {5047#false} is VALID [2018-11-23 12:09:13,216 INFO L273 TraceCheckUtils]: 37: Hoare triple {5047#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 + 7 * ~j~0), 4); {5047#false} is VALID [2018-11-23 12:09:13,216 INFO L256 TraceCheckUtils]: 38: Hoare triple {5047#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {5047#false} is VALID [2018-11-23 12:09:13,216 INFO L273 TraceCheckUtils]: 39: Hoare triple {5047#false} ~cond := #in~cond; {5047#false} is VALID [2018-11-23 12:09:13,216 INFO L273 TraceCheckUtils]: 40: Hoare triple {5047#false} assume 0 == ~cond; {5047#false} is VALID [2018-11-23 12:09:13,217 INFO L273 TraceCheckUtils]: 41: Hoare triple {5047#false} assume !false; {5047#false} is VALID [2018-11-23 12:09:13,219 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:13,219 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:13,219 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:13,230 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:09:13,310 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 4 check-sat command(s) [2018-11-23 12:09:13,310 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:13,322 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:13,323 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:13,434 INFO L256 TraceCheckUtils]: 0: Hoare triple {5046#true} call ULTIMATE.init(); {5046#true} is VALID [2018-11-23 12:09:13,434 INFO L273 TraceCheckUtils]: 1: Hoare triple {5046#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {5046#true} is VALID [2018-11-23 12:09:13,434 INFO L273 TraceCheckUtils]: 2: Hoare triple {5046#true} assume true; {5046#true} is VALID [2018-11-23 12:09:13,434 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {5046#true} {5046#true} #60#return; {5046#true} is VALID [2018-11-23 12:09:13,435 INFO L256 TraceCheckUtils]: 4: Hoare triple {5046#true} call #t~ret4 := main(); {5046#true} is VALID [2018-11-23 12:09:13,435 INFO L273 TraceCheckUtils]: 5: Hoare triple {5046#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; {5046#true} is VALID [2018-11-23 12:09:13,435 INFO L273 TraceCheckUtils]: 6: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,435 INFO L273 TraceCheckUtils]: 7: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,435 INFO L273 TraceCheckUtils]: 8: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,436 INFO L273 TraceCheckUtils]: 9: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,436 INFO L273 TraceCheckUtils]: 10: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,436 INFO L273 TraceCheckUtils]: 11: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,436 INFO L273 TraceCheckUtils]: 12: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,436 INFO L273 TraceCheckUtils]: 13: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,437 INFO L273 TraceCheckUtils]: 14: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,437 INFO L273 TraceCheckUtils]: 15: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,437 INFO L273 TraceCheckUtils]: 16: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,437 INFO L273 TraceCheckUtils]: 17: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,437 INFO L273 TraceCheckUtils]: 18: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,437 INFO L273 TraceCheckUtils]: 19: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,437 INFO L273 TraceCheckUtils]: 20: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,437 INFO L273 TraceCheckUtils]: 21: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,438 INFO L273 TraceCheckUtils]: 22: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,438 INFO L273 TraceCheckUtils]: 23: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,438 INFO L273 TraceCheckUtils]: 24: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,438 INFO L273 TraceCheckUtils]: 25: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,438 INFO L273 TraceCheckUtils]: 26: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,438 INFO L273 TraceCheckUtils]: 27: Hoare triple {5046#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {5046#true} is VALID [2018-11-23 12:09:13,438 INFO L273 TraceCheckUtils]: 28: Hoare triple {5046#true} assume !(~i~0 < 100000); {5046#true} is VALID [2018-11-23 12:09:13,439 INFO L273 TraceCheckUtils]: 29: Hoare triple {5046#true} ~i~0 := 1; {5049#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:13,439 INFO L273 TraceCheckUtils]: 30: Hoare triple {5049#(<= 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5056#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:13,440 INFO L273 TraceCheckUtils]: 31: Hoare triple {5056#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5063#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:13,441 INFO L273 TraceCheckUtils]: 32: Hoare triple {5063#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5070#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:13,441 INFO L273 TraceCheckUtils]: 33: Hoare triple {5070#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5173#(<= main_~i~0 29)} is VALID [2018-11-23 12:09:13,442 INFO L273 TraceCheckUtils]: 34: Hoare triple {5173#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5177#(<= main_~i~0 36)} is VALID [2018-11-23 12:09:13,443 INFO L273 TraceCheckUtils]: 35: Hoare triple {5177#(<= main_~i~0 36)} assume !(~i~0 < 100000); {5047#false} is VALID [2018-11-23 12:09:13,443 INFO L273 TraceCheckUtils]: 36: Hoare triple {5047#false} ~i~0 := 1;~j~0 := 0; {5047#false} is VALID [2018-11-23 12:09:13,443 INFO L273 TraceCheckUtils]: 37: Hoare triple {5047#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 + 7 * ~j~0), 4); {5047#false} is VALID [2018-11-23 12:09:13,443 INFO L256 TraceCheckUtils]: 38: Hoare triple {5047#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {5047#false} is VALID [2018-11-23 12:09:13,444 INFO L273 TraceCheckUtils]: 39: Hoare triple {5047#false} ~cond := #in~cond; {5047#false} is VALID [2018-11-23 12:09:13,444 INFO L273 TraceCheckUtils]: 40: Hoare triple {5047#false} assume 0 == ~cond; {5047#false} is VALID [2018-11-23 12:09:13,444 INFO L273 TraceCheckUtils]: 41: Hoare triple {5047#false} assume !false; {5047#false} is VALID [2018-11-23 12:09:13,446 INFO L134 CoverageAnalysis]: Checked inductivity of 268 backedges. 0 proven. 15 refuted. 0 times theorem prover too weak. 253 trivial. 0 not checked. [2018-11-23 12:09:13,468 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:13,468 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [25, 8] total 27 [2018-11-23 12:09:13,468 INFO L78 Accepts]: Start accepts. Automaton has 27 states. Word has length 42 [2018-11-23 12:09:13,469 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:13,469 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 27 states. [2018-11-23 12:09:13,511 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 48 edges. 48 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:13,511 INFO L459 AbstractCegarLoop]: Interpolant automaton has 27 states [2018-11-23 12:09:13,512 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 27 interpolants. [2018-11-23 12:09:13,512 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=351, Invalid=351, Unknown=0, NotChecked=0, Total=702 [2018-11-23 12:09:13,513 INFO L87 Difference]: Start difference. First operand 46 states and 48 transitions. Second operand 27 states. [2018-11-23 12:09:14,316 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:14,316 INFO L93 Difference]: Finished difference Result 85 states and 98 transitions. [2018-11-23 12:09:14,316 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 27 states. [2018-11-23 12:09:14,316 INFO L78 Accepts]: Start accepts. Automaton has 27 states. Word has length 42 [2018-11-23 12:09:14,317 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:14,317 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 27 states. [2018-11-23 12:09:14,318 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 27 states to 27 states and 93 transitions. [2018-11-23 12:09:14,318 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 27 states. [2018-11-23 12:09:14,320 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 27 states to 27 states and 93 transitions. [2018-11-23 12:09:14,320 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 27 states and 93 transitions. [2018-11-23 12:09:14,404 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 93 edges. 93 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:14,406 INFO L225 Difference]: With dead ends: 85 [2018-11-23 12:09:14,407 INFO L226 Difference]: Without dead ends: 68 [2018-11-23 12:09:14,408 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 66 GetRequests, 41 SyntacticMatches, 0 SemanticMatches, 25 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.9s TimeCoverageRelationStatistics Valid=351, Invalid=351, Unknown=0, NotChecked=0, Total=702 [2018-11-23 12:09:14,408 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 68 states. [2018-11-23 12:09:14,440 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 68 to 50. [2018-11-23 12:09:14,440 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:14,440 INFO L82 GeneralOperation]: Start isEquivalent. First operand 68 states. Second operand 50 states. [2018-11-23 12:09:14,440 INFO L74 IsIncluded]: Start isIncluded. First operand 68 states. Second operand 50 states. [2018-11-23 12:09:14,440 INFO L87 Difference]: Start difference. First operand 68 states. Second operand 50 states. [2018-11-23 12:09:14,442 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:14,443 INFO L93 Difference]: Finished difference Result 68 states and 76 transitions. [2018-11-23 12:09:14,443 INFO L276 IsEmpty]: Start isEmpty. Operand 68 states and 76 transitions. [2018-11-23 12:09:14,443 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:14,443 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:14,443 INFO L74 IsIncluded]: Start isIncluded. First operand 50 states. Second operand 68 states. [2018-11-23 12:09:14,444 INFO L87 Difference]: Start difference. First operand 50 states. Second operand 68 states. [2018-11-23 12:09:14,445 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:14,446 INFO L93 Difference]: Finished difference Result 68 states and 76 transitions. [2018-11-23 12:09:14,446 INFO L276 IsEmpty]: Start isEmpty. Operand 68 states and 76 transitions. [2018-11-23 12:09:14,446 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:14,446 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:14,447 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:14,447 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:14,447 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 50 states. [2018-11-23 12:09:14,448 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 50 states to 50 states and 52 transitions. [2018-11-23 12:09:14,448 INFO L78 Accepts]: Start accepts. Automaton has 50 states and 52 transitions. Word has length 42 [2018-11-23 12:09:14,448 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:14,448 INFO L480 AbstractCegarLoop]: Abstraction has 50 states and 52 transitions. [2018-11-23 12:09:14,448 INFO L481 AbstractCegarLoop]: Interpolant automaton has 27 states. [2018-11-23 12:09:14,448 INFO L276 IsEmpty]: Start isEmpty. Operand 50 states and 52 transitions. [2018-11-23 12:09:14,449 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 47 [2018-11-23 12:09:14,449 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:14,449 INFO L402 BasicCegarLoop]: trace histogram [25, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:14,449 INFO L423 AbstractCegarLoop]: === Iteration 19 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:14,449 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:14,450 INFO L82 PathProgramCache]: Analyzing trace with hash -483291158, now seen corresponding path program 16 times [2018-11-23 12:09:14,450 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:14,450 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:14,451 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:14,451 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:14,451 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:14,480 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:16,145 INFO L256 TraceCheckUtils]: 0: Hoare triple {5570#true} call ULTIMATE.init(); {5570#true} is VALID [2018-11-23 12:09:16,146 INFO L273 TraceCheckUtils]: 1: Hoare triple {5570#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {5570#true} is VALID [2018-11-23 12:09:16,146 INFO L273 TraceCheckUtils]: 2: Hoare triple {5570#true} assume true; {5570#true} is VALID [2018-11-23 12:09:16,146 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {5570#true} {5570#true} #60#return; {5570#true} is VALID [2018-11-23 12:09:16,146 INFO L256 TraceCheckUtils]: 4: Hoare triple {5570#true} call #t~ret4 := main(); {5570#true} is VALID [2018-11-23 12:09:16,147 INFO L273 TraceCheckUtils]: 5: Hoare triple {5570#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; {5572#(= main_~i~0 0)} is VALID [2018-11-23 12:09:16,148 INFO L273 TraceCheckUtils]: 6: Hoare triple {5572#(= 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; {5573#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:16,149 INFO L273 TraceCheckUtils]: 7: Hoare triple {5573#(<= 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; {5574#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:16,150 INFO L273 TraceCheckUtils]: 8: Hoare triple {5574#(<= 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; {5575#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:16,151 INFO L273 TraceCheckUtils]: 9: Hoare triple {5575#(<= 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; {5576#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:16,151 INFO L273 TraceCheckUtils]: 10: Hoare triple {5576#(<= 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; {5577#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:16,152 INFO L273 TraceCheckUtils]: 11: Hoare triple {5577#(<= 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; {5578#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:16,152 INFO L273 TraceCheckUtils]: 12: Hoare triple {5578#(<= 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; {5579#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:16,153 INFO L273 TraceCheckUtils]: 13: Hoare triple {5579#(<= 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; {5580#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:16,154 INFO L273 TraceCheckUtils]: 14: Hoare triple {5580#(<= 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; {5581#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:16,155 INFO L273 TraceCheckUtils]: 15: Hoare triple {5581#(<= 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; {5582#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:16,156 INFO L273 TraceCheckUtils]: 16: Hoare triple {5582#(<= 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; {5583#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:16,157 INFO L273 TraceCheckUtils]: 17: Hoare triple {5583#(<= 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; {5584#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:16,158 INFO L273 TraceCheckUtils]: 18: Hoare triple {5584#(<= 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; {5585#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:16,159 INFO L273 TraceCheckUtils]: 19: Hoare triple {5585#(<= 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; {5586#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:16,160 INFO L273 TraceCheckUtils]: 20: Hoare triple {5586#(<= 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; {5587#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:16,160 INFO L273 TraceCheckUtils]: 21: Hoare triple {5587#(<= 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; {5588#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:16,161 INFO L273 TraceCheckUtils]: 22: Hoare triple {5588#(<= 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; {5589#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:16,162 INFO L273 TraceCheckUtils]: 23: Hoare triple {5589#(<= 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; {5590#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:16,163 INFO L273 TraceCheckUtils]: 24: Hoare triple {5590#(<= 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; {5591#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:16,164 INFO L273 TraceCheckUtils]: 25: Hoare triple {5591#(<= 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; {5592#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:16,165 INFO L273 TraceCheckUtils]: 26: Hoare triple {5592#(<= 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; {5593#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:16,166 INFO L273 TraceCheckUtils]: 27: Hoare triple {5593#(<= 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; {5594#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:16,167 INFO L273 TraceCheckUtils]: 28: Hoare triple {5594#(<= 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; {5595#(<= main_~i~0 23)} is VALID [2018-11-23 12:09:16,168 INFO L273 TraceCheckUtils]: 29: Hoare triple {5595#(<= 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; {5596#(<= main_~i~0 24)} is VALID [2018-11-23 12:09:16,169 INFO L273 TraceCheckUtils]: 30: Hoare triple {5596#(<= 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; {5597#(<= main_~i~0 25)} is VALID [2018-11-23 12:09:16,170 INFO L273 TraceCheckUtils]: 31: Hoare triple {5597#(<= main_~i~0 25)} assume !(~i~0 < 100000); {5571#false} is VALID [2018-11-23 12:09:16,170 INFO L273 TraceCheckUtils]: 32: Hoare triple {5571#false} ~i~0 := 1; {5571#false} is VALID [2018-11-23 12:09:16,170 INFO L273 TraceCheckUtils]: 33: Hoare triple {5571#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5571#false} is VALID [2018-11-23 12:09:16,170 INFO L273 TraceCheckUtils]: 34: Hoare triple {5571#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5571#false} is VALID [2018-11-23 12:09:16,170 INFO L273 TraceCheckUtils]: 35: Hoare triple {5571#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5571#false} is VALID [2018-11-23 12:09:16,171 INFO L273 TraceCheckUtils]: 36: Hoare triple {5571#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5571#false} is VALID [2018-11-23 12:09:16,171 INFO L273 TraceCheckUtils]: 37: Hoare triple {5571#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5571#false} is VALID [2018-11-23 12:09:16,171 INFO L273 TraceCheckUtils]: 38: Hoare triple {5571#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5571#false} is VALID [2018-11-23 12:09:16,171 INFO L273 TraceCheckUtils]: 39: Hoare triple {5571#false} assume !(~i~0 < 100000); {5571#false} is VALID [2018-11-23 12:09:16,171 INFO L273 TraceCheckUtils]: 40: Hoare triple {5571#false} ~i~0 := 1;~j~0 := 0; {5571#false} is VALID [2018-11-23 12:09:16,172 INFO L273 TraceCheckUtils]: 41: Hoare triple {5571#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 + 7 * ~j~0), 4); {5571#false} is VALID [2018-11-23 12:09:16,172 INFO L256 TraceCheckUtils]: 42: Hoare triple {5571#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {5571#false} is VALID [2018-11-23 12:09:16,172 INFO L273 TraceCheckUtils]: 43: Hoare triple {5571#false} ~cond := #in~cond; {5571#false} is VALID [2018-11-23 12:09:16,172 INFO L273 TraceCheckUtils]: 44: Hoare triple {5571#false} assume 0 == ~cond; {5571#false} is VALID [2018-11-23 12:09:16,172 INFO L273 TraceCheckUtils]: 45: Hoare triple {5571#false} assume !false; {5571#false} is VALID [2018-11-23 12:09:16,174 INFO L134 CoverageAnalysis]: Checked inductivity of 346 backedges. 0 proven. 325 refuted. 0 times theorem prover too weak. 21 trivial. 0 not checked. [2018-11-23 12:09:16,174 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:16,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 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:09:16,182 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:09:16,219 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:09:16,219 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:16,234 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:16,235 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:16,456 INFO L256 TraceCheckUtils]: 0: Hoare triple {5570#true} call ULTIMATE.init(); {5570#true} is VALID [2018-11-23 12:09:16,456 INFO L273 TraceCheckUtils]: 1: Hoare triple {5570#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {5570#true} is VALID [2018-11-23 12:09:16,456 INFO L273 TraceCheckUtils]: 2: Hoare triple {5570#true} assume true; {5570#true} is VALID [2018-11-23 12:09:16,456 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {5570#true} {5570#true} #60#return; {5570#true} is VALID [2018-11-23 12:09:16,456 INFO L256 TraceCheckUtils]: 4: Hoare triple {5570#true} call #t~ret4 := main(); {5570#true} is VALID [2018-11-23 12:09:16,457 INFO L273 TraceCheckUtils]: 5: Hoare triple {5570#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; {5616#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:16,458 INFO L273 TraceCheckUtils]: 6: Hoare triple {5616#(<= 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; {5573#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:16,458 INFO L273 TraceCheckUtils]: 7: Hoare triple {5573#(<= 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; {5574#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:16,459 INFO L273 TraceCheckUtils]: 8: Hoare triple {5574#(<= 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; {5575#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:16,460 INFO L273 TraceCheckUtils]: 9: Hoare triple {5575#(<= 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; {5576#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:16,460 INFO L273 TraceCheckUtils]: 10: Hoare triple {5576#(<= 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; {5577#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:16,461 INFO L273 TraceCheckUtils]: 11: Hoare triple {5577#(<= 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; {5578#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:16,462 INFO L273 TraceCheckUtils]: 12: Hoare triple {5578#(<= 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; {5579#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:16,463 INFO L273 TraceCheckUtils]: 13: Hoare triple {5579#(<= 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; {5580#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:16,464 INFO L273 TraceCheckUtils]: 14: Hoare triple {5580#(<= 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; {5581#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:16,465 INFO L273 TraceCheckUtils]: 15: Hoare triple {5581#(<= 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; {5582#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:16,466 INFO L273 TraceCheckUtils]: 16: Hoare triple {5582#(<= 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; {5583#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:16,467 INFO L273 TraceCheckUtils]: 17: Hoare triple {5583#(<= 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; {5584#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:16,468 INFO L273 TraceCheckUtils]: 18: Hoare triple {5584#(<= 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; {5585#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:16,469 INFO L273 TraceCheckUtils]: 19: Hoare triple {5585#(<= 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; {5586#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:16,470 INFO L273 TraceCheckUtils]: 20: Hoare triple {5586#(<= 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; {5587#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:16,471 INFO L273 TraceCheckUtils]: 21: Hoare triple {5587#(<= 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; {5588#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:16,472 INFO L273 TraceCheckUtils]: 22: Hoare triple {5588#(<= 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; {5589#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:16,473 INFO L273 TraceCheckUtils]: 23: Hoare triple {5589#(<= 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; {5590#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:16,474 INFO L273 TraceCheckUtils]: 24: Hoare triple {5590#(<= 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; {5591#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:16,475 INFO L273 TraceCheckUtils]: 25: Hoare triple {5591#(<= 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; {5592#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:16,476 INFO L273 TraceCheckUtils]: 26: Hoare triple {5592#(<= 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; {5593#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:16,477 INFO L273 TraceCheckUtils]: 27: Hoare triple {5593#(<= 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; {5594#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:16,479 INFO L273 TraceCheckUtils]: 28: Hoare triple {5594#(<= 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; {5595#(<= main_~i~0 23)} is VALID [2018-11-23 12:09:16,480 INFO L273 TraceCheckUtils]: 29: Hoare triple {5595#(<= 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; {5596#(<= main_~i~0 24)} is VALID [2018-11-23 12:09:16,481 INFO L273 TraceCheckUtils]: 30: Hoare triple {5596#(<= 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; {5597#(<= main_~i~0 25)} is VALID [2018-11-23 12:09:16,481 INFO L273 TraceCheckUtils]: 31: Hoare triple {5597#(<= main_~i~0 25)} assume !(~i~0 < 100000); {5571#false} is VALID [2018-11-23 12:09:16,481 INFO L273 TraceCheckUtils]: 32: Hoare triple {5571#false} ~i~0 := 1; {5571#false} is VALID [2018-11-23 12:09:16,482 INFO L273 TraceCheckUtils]: 33: Hoare triple {5571#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5571#false} is VALID [2018-11-23 12:09:16,482 INFO L273 TraceCheckUtils]: 34: Hoare triple {5571#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5571#false} is VALID [2018-11-23 12:09:16,482 INFO L273 TraceCheckUtils]: 35: Hoare triple {5571#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5571#false} is VALID [2018-11-23 12:09:16,482 INFO L273 TraceCheckUtils]: 36: Hoare triple {5571#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5571#false} is VALID [2018-11-23 12:09:16,483 INFO L273 TraceCheckUtils]: 37: Hoare triple {5571#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5571#false} is VALID [2018-11-23 12:09:16,483 INFO L273 TraceCheckUtils]: 38: Hoare triple {5571#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {5571#false} is VALID [2018-11-23 12:09:16,483 INFO L273 TraceCheckUtils]: 39: Hoare triple {5571#false} assume !(~i~0 < 100000); {5571#false} is VALID [2018-11-23 12:09:16,483 INFO L273 TraceCheckUtils]: 40: Hoare triple {5571#false} ~i~0 := 1;~j~0 := 0; {5571#false} is VALID [2018-11-23 12:09:16,483 INFO L273 TraceCheckUtils]: 41: Hoare triple {5571#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 + 7 * ~j~0), 4); {5571#false} is VALID [2018-11-23 12:09:16,483 INFO L256 TraceCheckUtils]: 42: Hoare triple {5571#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {5571#false} is VALID [2018-11-23 12:09:16,484 INFO L273 TraceCheckUtils]: 43: Hoare triple {5571#false} ~cond := #in~cond; {5571#false} is VALID [2018-11-23 12:09:16,484 INFO L273 TraceCheckUtils]: 44: Hoare triple {5571#false} assume 0 == ~cond; {5571#false} is VALID [2018-11-23 12:09:16,484 INFO L273 TraceCheckUtils]: 45: Hoare triple {5571#false} assume !false; {5571#false} is VALID [2018-11-23 12:09:16,485 INFO L134 CoverageAnalysis]: Checked inductivity of 346 backedges. 0 proven. 325 refuted. 0 times theorem prover too weak. 21 trivial. 0 not checked. [2018-11-23 12:09:16,504 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:16,504 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [28, 28] total 29 [2018-11-23 12:09:16,504 INFO L78 Accepts]: Start accepts. Automaton has 29 states. Word has length 46 [2018-11-23 12:09:16,505 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:16,505 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 29 states. [2018-11-23 12:09:16,540 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:16,540 INFO L459 AbstractCegarLoop]: Interpolant automaton has 29 states [2018-11-23 12:09:16,540 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 29 interpolants. [2018-11-23 12:09:16,541 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=406, Invalid=406, Unknown=0, NotChecked=0, Total=812 [2018-11-23 12:09:16,541 INFO L87 Difference]: Start difference. First operand 50 states and 52 transitions. Second operand 29 states. [2018-11-23 12:09:17,281 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:17,281 INFO L93 Difference]: Finished difference Result 81 states and 89 transitions. [2018-11-23 12:09:17,281 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 28 states. [2018-11-23 12:09:17,281 INFO L78 Accepts]: Start accepts. Automaton has 29 states. Word has length 46 [2018-11-23 12:09:17,282 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:17,282 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 29 states. [2018-11-23 12:09:17,284 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 28 states to 28 states and 81 transitions. [2018-11-23 12:09:17,284 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 29 states. [2018-11-23 12:09:17,285 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 28 states to 28 states and 81 transitions. [2018-11-23 12:09:17,285 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 28 states and 81 transitions. [2018-11-23 12:09:18,092 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 81 edges. 81 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:18,096 INFO L225 Difference]: With dead ends: 81 [2018-11-23 12:09:18,096 INFO L226 Difference]: Without dead ends: 63 [2018-11-23 12:09:18,097 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 73 GetRequests, 46 SyntacticMatches, 0 SemanticMatches, 27 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 48 ImplicationChecksByTransitivity, 1.3s TimeCoverageRelationStatistics Valid=406, Invalid=406, Unknown=0, NotChecked=0, Total=812 [2018-11-23 12:09:18,097 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 63 states. [2018-11-23 12:09:18,132 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 63 to 51. [2018-11-23 12:09:18,132 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:18,133 INFO L82 GeneralOperation]: Start isEquivalent. First operand 63 states. Second operand 51 states. [2018-11-23 12:09:18,133 INFO L74 IsIncluded]: Start isIncluded. First operand 63 states. Second operand 51 states. [2018-11-23 12:09:18,133 INFO L87 Difference]: Start difference. First operand 63 states. Second operand 51 states. [2018-11-23 12:09:18,135 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:18,135 INFO L93 Difference]: Finished difference Result 63 states and 69 transitions. [2018-11-23 12:09:18,136 INFO L276 IsEmpty]: Start isEmpty. Operand 63 states and 69 transitions. [2018-11-23 12:09:18,136 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:18,136 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:18,136 INFO L74 IsIncluded]: Start isIncluded. First operand 51 states. Second operand 63 states. [2018-11-23 12:09:18,136 INFO L87 Difference]: Start difference. First operand 51 states. Second operand 63 states. [2018-11-23 12:09:18,137 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:18,138 INFO L93 Difference]: Finished difference Result 63 states and 69 transitions. [2018-11-23 12:09:18,138 INFO L276 IsEmpty]: Start isEmpty. Operand 63 states and 69 transitions. [2018-11-23 12:09:18,138 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:18,138 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:18,138 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:18,139 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:18,139 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 51 states. [2018-11-23 12:09:18,140 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 51 states to 51 states and 53 transitions. [2018-11-23 12:09:18,140 INFO L78 Accepts]: Start accepts. Automaton has 51 states and 53 transitions. Word has length 46 [2018-11-23 12:09:18,140 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:18,140 INFO L480 AbstractCegarLoop]: Abstraction has 51 states and 53 transitions. [2018-11-23 12:09:18,140 INFO L481 AbstractCegarLoop]: Interpolant automaton has 29 states. [2018-11-23 12:09:18,140 INFO L276 IsEmpty]: Start isEmpty. Operand 51 states and 53 transitions. [2018-11-23 12:09:18,141 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 48 [2018-11-23 12:09:18,141 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:18,141 INFO L402 BasicCegarLoop]: trace histogram [26, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:18,141 INFO L423 AbstractCegarLoop]: === Iteration 20 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:18,141 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:18,141 INFO L82 PathProgramCache]: Analyzing trace with hash -1141401786, now seen corresponding path program 17 times [2018-11-23 12:09:18,142 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:18,142 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:18,142 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:18,142 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:18,143 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:18,164 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:18,980 INFO L256 TraceCheckUtils]: 0: Hoare triple {6094#true} call ULTIMATE.init(); {6094#true} is VALID [2018-11-23 12:09:18,981 INFO L273 TraceCheckUtils]: 1: Hoare triple {6094#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {6094#true} is VALID [2018-11-23 12:09:18,981 INFO L273 TraceCheckUtils]: 2: Hoare triple {6094#true} assume true; {6094#true} is VALID [2018-11-23 12:09:18,981 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {6094#true} {6094#true} #60#return; {6094#true} is VALID [2018-11-23 12:09:18,981 INFO L256 TraceCheckUtils]: 4: Hoare triple {6094#true} call #t~ret4 := main(); {6094#true} is VALID [2018-11-23 12:09:18,982 INFO L273 TraceCheckUtils]: 5: Hoare triple {6094#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; {6096#(= main_~i~0 0)} is VALID [2018-11-23 12:09:18,983 INFO L273 TraceCheckUtils]: 6: Hoare triple {6096#(= 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; {6097#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:18,984 INFO L273 TraceCheckUtils]: 7: Hoare triple {6097#(<= 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; {6098#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:18,985 INFO L273 TraceCheckUtils]: 8: Hoare triple {6098#(<= 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; {6099#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:18,986 INFO L273 TraceCheckUtils]: 9: Hoare triple {6099#(<= 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; {6100#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:18,987 INFO L273 TraceCheckUtils]: 10: Hoare triple {6100#(<= 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; {6101#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:18,988 INFO L273 TraceCheckUtils]: 11: Hoare triple {6101#(<= 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; {6102#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:18,989 INFO L273 TraceCheckUtils]: 12: Hoare triple {6102#(<= 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; {6103#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:18,990 INFO L273 TraceCheckUtils]: 13: Hoare triple {6103#(<= 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; {6104#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:18,991 INFO L273 TraceCheckUtils]: 14: Hoare triple {6104#(<= 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; {6105#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:18,992 INFO L273 TraceCheckUtils]: 15: Hoare triple {6105#(<= 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; {6106#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:18,992 INFO L273 TraceCheckUtils]: 16: Hoare triple {6106#(<= 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; {6107#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:18,993 INFO L273 TraceCheckUtils]: 17: Hoare triple {6107#(<= 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; {6108#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:18,994 INFO L273 TraceCheckUtils]: 18: Hoare triple {6108#(<= 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; {6109#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:18,995 INFO L273 TraceCheckUtils]: 19: Hoare triple {6109#(<= 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; {6110#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:18,996 INFO L273 TraceCheckUtils]: 20: Hoare triple {6110#(<= 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; {6111#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:18,997 INFO L273 TraceCheckUtils]: 21: Hoare triple {6111#(<= 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; {6112#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:18,998 INFO L273 TraceCheckUtils]: 22: Hoare triple {6112#(<= 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; {6113#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:18,999 INFO L273 TraceCheckUtils]: 23: Hoare triple {6113#(<= 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; {6114#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:19,000 INFO L273 TraceCheckUtils]: 24: Hoare triple {6114#(<= 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; {6115#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:19,001 INFO L273 TraceCheckUtils]: 25: Hoare triple {6115#(<= 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; {6116#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:19,002 INFO L273 TraceCheckUtils]: 26: Hoare triple {6116#(<= 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; {6117#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:19,003 INFO L273 TraceCheckUtils]: 27: Hoare triple {6117#(<= 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; {6118#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:19,004 INFO L273 TraceCheckUtils]: 28: Hoare triple {6118#(<= 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; {6119#(<= main_~i~0 23)} is VALID [2018-11-23 12:09:19,005 INFO L273 TraceCheckUtils]: 29: Hoare triple {6119#(<= 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; {6120#(<= main_~i~0 24)} is VALID [2018-11-23 12:09:19,006 INFO L273 TraceCheckUtils]: 30: Hoare triple {6120#(<= 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; {6121#(<= main_~i~0 25)} is VALID [2018-11-23 12:09:19,007 INFO L273 TraceCheckUtils]: 31: Hoare triple {6121#(<= 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; {6122#(<= main_~i~0 26)} is VALID [2018-11-23 12:09:19,007 INFO L273 TraceCheckUtils]: 32: Hoare triple {6122#(<= main_~i~0 26)} assume !(~i~0 < 100000); {6095#false} is VALID [2018-11-23 12:09:19,008 INFO L273 TraceCheckUtils]: 33: Hoare triple {6095#false} ~i~0 := 1; {6095#false} is VALID [2018-11-23 12:09:19,008 INFO L273 TraceCheckUtils]: 34: Hoare triple {6095#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6095#false} is VALID [2018-11-23 12:09:19,008 INFO L273 TraceCheckUtils]: 35: Hoare triple {6095#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6095#false} is VALID [2018-11-23 12:09:19,008 INFO L273 TraceCheckUtils]: 36: Hoare triple {6095#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6095#false} is VALID [2018-11-23 12:09:19,008 INFO L273 TraceCheckUtils]: 37: Hoare triple {6095#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6095#false} is VALID [2018-11-23 12:09:19,009 INFO L273 TraceCheckUtils]: 38: Hoare triple {6095#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6095#false} is VALID [2018-11-23 12:09:19,009 INFO L273 TraceCheckUtils]: 39: Hoare triple {6095#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6095#false} is VALID [2018-11-23 12:09:19,009 INFO L273 TraceCheckUtils]: 40: Hoare triple {6095#false} assume !(~i~0 < 100000); {6095#false} is VALID [2018-11-23 12:09:19,009 INFO L273 TraceCheckUtils]: 41: Hoare triple {6095#false} ~i~0 := 1;~j~0 := 0; {6095#false} is VALID [2018-11-23 12:09:19,009 INFO L273 TraceCheckUtils]: 42: Hoare triple {6095#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 + 7 * ~j~0), 4); {6095#false} is VALID [2018-11-23 12:09:19,010 INFO L256 TraceCheckUtils]: 43: Hoare triple {6095#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {6095#false} is VALID [2018-11-23 12:09:19,010 INFO L273 TraceCheckUtils]: 44: Hoare triple {6095#false} ~cond := #in~cond; {6095#false} is VALID [2018-11-23 12:09:19,010 INFO L273 TraceCheckUtils]: 45: Hoare triple {6095#false} assume 0 == ~cond; {6095#false} is VALID [2018-11-23 12:09:19,010 INFO L273 TraceCheckUtils]: 46: Hoare triple {6095#false} assume !false; {6095#false} is VALID [2018-11-23 12:09:19,013 INFO L134 CoverageAnalysis]: Checked inductivity of 372 backedges. 0 proven. 351 refuted. 0 times theorem prover too weak. 21 trivial. 0 not checked. [2018-11-23 12:09:19,013 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:19,013 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:09:19,023 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:09:25,837 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 14 check-sat command(s) [2018-11-23 12:09:25,837 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:25,856 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:25,857 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:26,015 INFO L256 TraceCheckUtils]: 0: Hoare triple {6094#true} call ULTIMATE.init(); {6094#true} is VALID [2018-11-23 12:09:26,015 INFO L273 TraceCheckUtils]: 1: Hoare triple {6094#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {6094#true} is VALID [2018-11-23 12:09:26,015 INFO L273 TraceCheckUtils]: 2: Hoare triple {6094#true} assume true; {6094#true} is VALID [2018-11-23 12:09:26,016 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {6094#true} {6094#true} #60#return; {6094#true} is VALID [2018-11-23 12:09:26,016 INFO L256 TraceCheckUtils]: 4: Hoare triple {6094#true} call #t~ret4 := main(); {6094#true} is VALID [2018-11-23 12:09:26,016 INFO L273 TraceCheckUtils]: 5: Hoare triple {6094#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; {6094#true} is VALID [2018-11-23 12:09:26,016 INFO L273 TraceCheckUtils]: 6: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,016 INFO L273 TraceCheckUtils]: 7: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,017 INFO L273 TraceCheckUtils]: 8: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,017 INFO L273 TraceCheckUtils]: 9: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,017 INFO L273 TraceCheckUtils]: 10: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,017 INFO L273 TraceCheckUtils]: 11: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,017 INFO L273 TraceCheckUtils]: 12: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,018 INFO L273 TraceCheckUtils]: 13: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,018 INFO L273 TraceCheckUtils]: 14: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,018 INFO L273 TraceCheckUtils]: 15: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,018 INFO L273 TraceCheckUtils]: 16: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,018 INFO L273 TraceCheckUtils]: 17: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,018 INFO L273 TraceCheckUtils]: 18: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,018 INFO L273 TraceCheckUtils]: 19: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,018 INFO L273 TraceCheckUtils]: 20: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,019 INFO L273 TraceCheckUtils]: 21: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,019 INFO L273 TraceCheckUtils]: 22: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,019 INFO L273 TraceCheckUtils]: 23: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,019 INFO L273 TraceCheckUtils]: 24: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,019 INFO L273 TraceCheckUtils]: 25: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,019 INFO L273 TraceCheckUtils]: 26: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,019 INFO L273 TraceCheckUtils]: 27: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,019 INFO L273 TraceCheckUtils]: 28: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,019 INFO L273 TraceCheckUtils]: 29: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,020 INFO L273 TraceCheckUtils]: 30: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,020 INFO L273 TraceCheckUtils]: 31: Hoare triple {6094#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {6094#true} is VALID [2018-11-23 12:09:26,020 INFO L273 TraceCheckUtils]: 32: Hoare triple {6094#true} assume !(~i~0 < 100000); {6094#true} is VALID [2018-11-23 12:09:26,020 INFO L273 TraceCheckUtils]: 33: Hoare triple {6094#true} ~i~0 := 1; {6097#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:26,021 INFO L273 TraceCheckUtils]: 34: Hoare triple {6097#(<= 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6104#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:26,022 INFO L273 TraceCheckUtils]: 35: Hoare triple {6104#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6111#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:26,022 INFO L273 TraceCheckUtils]: 36: Hoare triple {6111#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6118#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:26,023 INFO L273 TraceCheckUtils]: 37: Hoare triple {6118#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6237#(<= main_~i~0 29)} is VALID [2018-11-23 12:09:26,024 INFO L273 TraceCheckUtils]: 38: Hoare triple {6237#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6241#(<= main_~i~0 36)} is VALID [2018-11-23 12:09:26,025 INFO L273 TraceCheckUtils]: 39: Hoare triple {6241#(<= main_~i~0 36)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6245#(<= main_~i~0 43)} is VALID [2018-11-23 12:09:26,025 INFO L273 TraceCheckUtils]: 40: Hoare triple {6245#(<= main_~i~0 43)} assume !(~i~0 < 100000); {6095#false} is VALID [2018-11-23 12:09:26,026 INFO L273 TraceCheckUtils]: 41: Hoare triple {6095#false} ~i~0 := 1;~j~0 := 0; {6095#false} is VALID [2018-11-23 12:09:26,026 INFO L273 TraceCheckUtils]: 42: Hoare triple {6095#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 + 7 * ~j~0), 4); {6095#false} is VALID [2018-11-23 12:09:26,026 INFO L256 TraceCheckUtils]: 43: Hoare triple {6095#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {6095#false} is VALID [2018-11-23 12:09:26,026 INFO L273 TraceCheckUtils]: 44: Hoare triple {6095#false} ~cond := #in~cond; {6095#false} is VALID [2018-11-23 12:09:26,026 INFO L273 TraceCheckUtils]: 45: Hoare triple {6095#false} assume 0 == ~cond; {6095#false} is VALID [2018-11-23 12:09:26,027 INFO L273 TraceCheckUtils]: 46: Hoare triple {6095#false} assume !false; {6095#false} is VALID [2018-11-23 12:09:26,028 INFO L134 CoverageAnalysis]: Checked inductivity of 372 backedges. 0 proven. 21 refuted. 0 times theorem prover too weak. 351 trivial. 0 not checked. [2018-11-23 12:09:26,051 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:26,051 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [29, 9] total 32 [2018-11-23 12:09:26,051 INFO L78 Accepts]: Start accepts. Automaton has 32 states. Word has length 47 [2018-11-23 12:09:26,052 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:26,052 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 32 states. [2018-11-23 12:09:26,098 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 53 edges. 53 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:26,098 INFO L459 AbstractCegarLoop]: Interpolant automaton has 32 states [2018-11-23 12:09:26,098 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 32 interpolants. [2018-11-23 12:09:26,099 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=496, Invalid=496, Unknown=0, NotChecked=0, Total=992 [2018-11-23 12:09:26,099 INFO L87 Difference]: Start difference. First operand 51 states and 53 transitions. Second operand 32 states. [2018-11-23 12:09:27,093 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:27,093 INFO L93 Difference]: Finished difference Result 95 states and 110 transitions. [2018-11-23 12:09:27,094 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 32 states. [2018-11-23 12:09:27,094 INFO L78 Accepts]: Start accepts. Automaton has 32 states. Word has length 47 [2018-11-23 12:09:27,094 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:27,094 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 32 states. [2018-11-23 12:09:27,096 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 32 states to 32 states and 104 transitions. [2018-11-23 12:09:27,096 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 32 states. [2018-11-23 12:09:27,098 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 32 states to 32 states and 104 transitions. [2018-11-23 12:09:27,098 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 32 states and 104 transitions. [2018-11-23 12:09:27,247 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 104 edges. 104 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:27,249 INFO L225 Difference]: With dead ends: 95 [2018-11-23 12:09:27,250 INFO L226 Difference]: Without dead ends: 77 [2018-11-23 12:09:27,250 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 75 GetRequests, 45 SyntacticMatches, 0 SemanticMatches, 30 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.6s TimeCoverageRelationStatistics Valid=496, Invalid=496, Unknown=0, NotChecked=0, Total=992 [2018-11-23 12:09:27,250 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 77 states. [2018-11-23 12:09:27,293 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 77 to 56. [2018-11-23 12:09:27,294 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:27,294 INFO L82 GeneralOperation]: Start isEquivalent. First operand 77 states. Second operand 56 states. [2018-11-23 12:09:27,294 INFO L74 IsIncluded]: Start isIncluded. First operand 77 states. Second operand 56 states. [2018-11-23 12:09:27,295 INFO L87 Difference]: Start difference. First operand 77 states. Second operand 56 states. [2018-11-23 12:09:27,297 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:27,297 INFO L93 Difference]: Finished difference Result 77 states and 86 transitions. [2018-11-23 12:09:27,297 INFO L276 IsEmpty]: Start isEmpty. Operand 77 states and 86 transitions. [2018-11-23 12:09:27,298 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:27,298 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:27,298 INFO L74 IsIncluded]: Start isIncluded. First operand 56 states. Second operand 77 states. [2018-11-23 12:09:27,298 INFO L87 Difference]: Start difference. First operand 56 states. Second operand 77 states. [2018-11-23 12:09:27,300 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:27,300 INFO L93 Difference]: Finished difference Result 77 states and 86 transitions. [2018-11-23 12:09:27,300 INFO L276 IsEmpty]: Start isEmpty. Operand 77 states and 86 transitions. [2018-11-23 12:09:27,301 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:27,301 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:27,301 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:27,301 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:27,302 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 56 states. [2018-11-23 12:09:27,302 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 56 states to 56 states and 58 transitions. [2018-11-23 12:09:27,303 INFO L78 Accepts]: Start accepts. Automaton has 56 states and 58 transitions. Word has length 47 [2018-11-23 12:09:27,303 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:27,303 INFO L480 AbstractCegarLoop]: Abstraction has 56 states and 58 transitions. [2018-11-23 12:09:27,303 INFO L481 AbstractCegarLoop]: Interpolant automaton has 32 states. [2018-11-23 12:09:27,303 INFO L276 IsEmpty]: Start isEmpty. Operand 56 states and 58 transitions. [2018-11-23 12:09:27,304 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 53 [2018-11-23 12:09:27,304 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:27,304 INFO L402 BasicCegarLoop]: trace histogram [30, 7, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:27,304 INFO L423 AbstractCegarLoop]: === Iteration 21 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:27,304 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:27,305 INFO L82 PathProgramCache]: Analyzing trace with hash -531461431, now seen corresponding path program 18 times [2018-11-23 12:09:27,305 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:27,305 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:27,306 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:27,306 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:27,306 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:27,332 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:29,215 INFO L256 TraceCheckUtils]: 0: Hoare triple {6687#true} call ULTIMATE.init(); {6687#true} is VALID [2018-11-23 12:09:29,216 INFO L273 TraceCheckUtils]: 1: Hoare triple {6687#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {6687#true} is VALID [2018-11-23 12:09:29,216 INFO L273 TraceCheckUtils]: 2: Hoare triple {6687#true} assume true; {6687#true} is VALID [2018-11-23 12:09:29,216 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {6687#true} {6687#true} #60#return; {6687#true} is VALID [2018-11-23 12:09:29,216 INFO L256 TraceCheckUtils]: 4: Hoare triple {6687#true} call #t~ret4 := main(); {6687#true} is VALID [2018-11-23 12:09:29,217 INFO L273 TraceCheckUtils]: 5: Hoare triple {6687#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; {6689#(= main_~i~0 0)} is VALID [2018-11-23 12:09:29,218 INFO L273 TraceCheckUtils]: 6: Hoare triple {6689#(= 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; {6690#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:29,219 INFO L273 TraceCheckUtils]: 7: Hoare triple {6690#(<= 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; {6691#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:29,220 INFO L273 TraceCheckUtils]: 8: Hoare triple {6691#(<= 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; {6692#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:29,221 INFO L273 TraceCheckUtils]: 9: Hoare triple {6692#(<= 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; {6693#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:29,222 INFO L273 TraceCheckUtils]: 10: Hoare triple {6693#(<= 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; {6694#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:29,223 INFO L273 TraceCheckUtils]: 11: Hoare triple {6694#(<= 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; {6695#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:29,224 INFO L273 TraceCheckUtils]: 12: Hoare triple {6695#(<= 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; {6696#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:29,225 INFO L273 TraceCheckUtils]: 13: Hoare triple {6696#(<= 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; {6697#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:29,226 INFO L273 TraceCheckUtils]: 14: Hoare triple {6697#(<= 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; {6698#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:29,227 INFO L273 TraceCheckUtils]: 15: Hoare triple {6698#(<= 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; {6699#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:29,228 INFO L273 TraceCheckUtils]: 16: Hoare triple {6699#(<= 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; {6700#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:29,229 INFO L273 TraceCheckUtils]: 17: Hoare triple {6700#(<= 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; {6701#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:29,230 INFO L273 TraceCheckUtils]: 18: Hoare triple {6701#(<= 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; {6702#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:29,231 INFO L273 TraceCheckUtils]: 19: Hoare triple {6702#(<= 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; {6703#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:29,232 INFO L273 TraceCheckUtils]: 20: Hoare triple {6703#(<= 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; {6704#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:29,233 INFO L273 TraceCheckUtils]: 21: Hoare triple {6704#(<= 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; {6705#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:29,234 INFO L273 TraceCheckUtils]: 22: Hoare triple {6705#(<= 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; {6706#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:29,235 INFO L273 TraceCheckUtils]: 23: Hoare triple {6706#(<= 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; {6707#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:29,236 INFO L273 TraceCheckUtils]: 24: Hoare triple {6707#(<= 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; {6708#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:29,237 INFO L273 TraceCheckUtils]: 25: Hoare triple {6708#(<= 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; {6709#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:29,238 INFO L273 TraceCheckUtils]: 26: Hoare triple {6709#(<= 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; {6710#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:29,239 INFO L273 TraceCheckUtils]: 27: Hoare triple {6710#(<= 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; {6711#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:29,240 INFO L273 TraceCheckUtils]: 28: Hoare triple {6711#(<= 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; {6712#(<= main_~i~0 23)} is VALID [2018-11-23 12:09:29,241 INFO L273 TraceCheckUtils]: 29: Hoare triple {6712#(<= 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; {6713#(<= main_~i~0 24)} is VALID [2018-11-23 12:09:29,242 INFO L273 TraceCheckUtils]: 30: Hoare triple {6713#(<= 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; {6714#(<= main_~i~0 25)} is VALID [2018-11-23 12:09:29,243 INFO L273 TraceCheckUtils]: 31: Hoare triple {6714#(<= 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; {6715#(<= main_~i~0 26)} is VALID [2018-11-23 12:09:29,244 INFO L273 TraceCheckUtils]: 32: Hoare triple {6715#(<= 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; {6716#(<= main_~i~0 27)} is VALID [2018-11-23 12:09:29,245 INFO L273 TraceCheckUtils]: 33: Hoare triple {6716#(<= 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; {6717#(<= main_~i~0 28)} is VALID [2018-11-23 12:09:29,246 INFO L273 TraceCheckUtils]: 34: Hoare triple {6717#(<= 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; {6718#(<= main_~i~0 29)} is VALID [2018-11-23 12:09:29,247 INFO L273 TraceCheckUtils]: 35: Hoare triple {6718#(<= 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; {6719#(<= main_~i~0 30)} is VALID [2018-11-23 12:09:29,248 INFO L273 TraceCheckUtils]: 36: Hoare triple {6719#(<= main_~i~0 30)} assume !(~i~0 < 100000); {6688#false} is VALID [2018-11-23 12:09:29,248 INFO L273 TraceCheckUtils]: 37: Hoare triple {6688#false} ~i~0 := 1; {6688#false} is VALID [2018-11-23 12:09:29,248 INFO L273 TraceCheckUtils]: 38: Hoare triple {6688#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6688#false} is VALID [2018-11-23 12:09:29,249 INFO L273 TraceCheckUtils]: 39: Hoare triple {6688#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6688#false} is VALID [2018-11-23 12:09:29,249 INFO L273 TraceCheckUtils]: 40: Hoare triple {6688#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6688#false} is VALID [2018-11-23 12:09:29,249 INFO L273 TraceCheckUtils]: 41: Hoare triple {6688#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6688#false} is VALID [2018-11-23 12:09:29,249 INFO L273 TraceCheckUtils]: 42: Hoare triple {6688#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6688#false} is VALID [2018-11-23 12:09:29,250 INFO L273 TraceCheckUtils]: 43: Hoare triple {6688#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6688#false} is VALID [2018-11-23 12:09:29,250 INFO L273 TraceCheckUtils]: 44: Hoare triple {6688#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6688#false} is VALID [2018-11-23 12:09:29,250 INFO L273 TraceCheckUtils]: 45: Hoare triple {6688#false} assume !(~i~0 < 100000); {6688#false} is VALID [2018-11-23 12:09:29,250 INFO L273 TraceCheckUtils]: 46: Hoare triple {6688#false} ~i~0 := 1;~j~0 := 0; {6688#false} is VALID [2018-11-23 12:09:29,251 INFO L273 TraceCheckUtils]: 47: Hoare triple {6688#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 + 7 * ~j~0), 4); {6688#false} is VALID [2018-11-23 12:09:29,251 INFO L256 TraceCheckUtils]: 48: Hoare triple {6688#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {6688#false} is VALID [2018-11-23 12:09:29,251 INFO L273 TraceCheckUtils]: 49: Hoare triple {6688#false} ~cond := #in~cond; {6688#false} is VALID [2018-11-23 12:09:29,251 INFO L273 TraceCheckUtils]: 50: Hoare triple {6688#false} assume 0 == ~cond; {6688#false} is VALID [2018-11-23 12:09:29,251 INFO L273 TraceCheckUtils]: 51: Hoare triple {6688#false} assume !false; {6688#false} is VALID [2018-11-23 12:09:29,254 INFO L134 CoverageAnalysis]: Checked inductivity of 493 backedges. 0 proven. 465 refuted. 0 times theorem prover too weak. 28 trivial. 0 not checked. [2018-11-23 12:09:29,254 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:29,254 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:09:29,272 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE [2018-11-23 12:09:31,642 INFO L249 tOrderPrioritization]: Assert order MIX_INSIDE_OUTSIDE issued 9 check-sat command(s) [2018-11-23 12:09:31,642 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:31,656 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:31,657 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:31,910 INFO L256 TraceCheckUtils]: 0: Hoare triple {6687#true} call ULTIMATE.init(); {6687#true} is VALID [2018-11-23 12:09:31,911 INFO L273 TraceCheckUtils]: 1: Hoare triple {6687#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {6687#true} is VALID [2018-11-23 12:09:31,911 INFO L273 TraceCheckUtils]: 2: Hoare triple {6687#true} assume true; {6687#true} is VALID [2018-11-23 12:09:31,911 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {6687#true} {6687#true} #60#return; {6687#true} is VALID [2018-11-23 12:09:31,911 INFO L256 TraceCheckUtils]: 4: Hoare triple {6687#true} call #t~ret4 := main(); {6687#true} is VALID [2018-11-23 12:09:31,911 INFO L273 TraceCheckUtils]: 5: Hoare triple {6687#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; {6687#true} is VALID [2018-11-23 12:09:31,912 INFO L273 TraceCheckUtils]: 6: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,912 INFO L273 TraceCheckUtils]: 7: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,912 INFO L273 TraceCheckUtils]: 8: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,912 INFO L273 TraceCheckUtils]: 9: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,912 INFO L273 TraceCheckUtils]: 10: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,912 INFO L273 TraceCheckUtils]: 11: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,913 INFO L273 TraceCheckUtils]: 12: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,913 INFO L273 TraceCheckUtils]: 13: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,913 INFO L273 TraceCheckUtils]: 14: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,913 INFO L273 TraceCheckUtils]: 15: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,913 INFO L273 TraceCheckUtils]: 16: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,913 INFO L273 TraceCheckUtils]: 17: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,914 INFO L273 TraceCheckUtils]: 18: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,914 INFO L273 TraceCheckUtils]: 19: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,914 INFO L273 TraceCheckUtils]: 20: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,914 INFO L273 TraceCheckUtils]: 21: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,914 INFO L273 TraceCheckUtils]: 22: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,914 INFO L273 TraceCheckUtils]: 23: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,915 INFO L273 TraceCheckUtils]: 24: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,915 INFO L273 TraceCheckUtils]: 25: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,915 INFO L273 TraceCheckUtils]: 26: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,915 INFO L273 TraceCheckUtils]: 27: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,915 INFO L273 TraceCheckUtils]: 28: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,915 INFO L273 TraceCheckUtils]: 29: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,916 INFO L273 TraceCheckUtils]: 30: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,916 INFO L273 TraceCheckUtils]: 31: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,916 INFO L273 TraceCheckUtils]: 32: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,916 INFO L273 TraceCheckUtils]: 33: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,916 INFO L273 TraceCheckUtils]: 34: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,917 INFO L273 TraceCheckUtils]: 35: Hoare triple {6687#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 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#true} is VALID [2018-11-23 12:09:31,917 INFO L273 TraceCheckUtils]: 36: Hoare triple {6687#true} assume !(~i~0 < 100000); {6687#true} is VALID [2018-11-23 12:09:31,929 INFO L273 TraceCheckUtils]: 37: Hoare triple {6687#true} ~i~0 := 1; {6690#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:31,931 INFO L273 TraceCheckUtils]: 38: Hoare triple {6690#(<= 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6697#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:31,931 INFO L273 TraceCheckUtils]: 39: Hoare triple {6697#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6704#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:31,933 INFO L273 TraceCheckUtils]: 40: Hoare triple {6704#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6711#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:31,933 INFO L273 TraceCheckUtils]: 41: Hoare triple {6711#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6718#(<= main_~i~0 29)} is VALID [2018-11-23 12:09:31,935 INFO L273 TraceCheckUtils]: 42: Hoare triple {6718#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6849#(<= main_~i~0 36)} is VALID [2018-11-23 12:09:31,936 INFO L273 TraceCheckUtils]: 43: Hoare triple {6849#(<= main_~i~0 36)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6853#(<= main_~i~0 43)} is VALID [2018-11-23 12:09:31,937 INFO L273 TraceCheckUtils]: 44: Hoare triple {6853#(<= main_~i~0 43)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {6857#(<= main_~i~0 50)} is VALID [2018-11-23 12:09:31,938 INFO L273 TraceCheckUtils]: 45: Hoare triple {6857#(<= main_~i~0 50)} assume !(~i~0 < 100000); {6688#false} is VALID [2018-11-23 12:09:31,938 INFO L273 TraceCheckUtils]: 46: Hoare triple {6688#false} ~i~0 := 1;~j~0 := 0; {6688#false} is VALID [2018-11-23 12:09:31,938 INFO L273 TraceCheckUtils]: 47: Hoare triple {6688#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 + 7 * ~j~0), 4); {6688#false} is VALID [2018-11-23 12:09:31,938 INFO L256 TraceCheckUtils]: 48: Hoare triple {6688#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {6688#false} is VALID [2018-11-23 12:09:31,939 INFO L273 TraceCheckUtils]: 49: Hoare triple {6688#false} ~cond := #in~cond; {6688#false} is VALID [2018-11-23 12:09:31,939 INFO L273 TraceCheckUtils]: 50: Hoare triple {6688#false} assume 0 == ~cond; {6688#false} is VALID [2018-11-23 12:09:31,939 INFO L273 TraceCheckUtils]: 51: Hoare triple {6688#false} assume !false; {6688#false} is VALID [2018-11-23 12:09:31,941 INFO L134 CoverageAnalysis]: Checked inductivity of 493 backedges. 0 proven. 28 refuted. 0 times theorem prover too weak. 465 trivial. 0 not checked. [2018-11-23 12:09:31,962 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:31,962 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [33, 10] total 36 [2018-11-23 12:09:31,962 INFO L78 Accepts]: Start accepts. Automaton has 36 states. Word has length 52 [2018-11-23 12:09:31,963 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:31,963 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 36 states. [2018-11-23 12:09:32,016 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:09:32,016 INFO L459 AbstractCegarLoop]: Interpolant automaton has 36 states [2018-11-23 12:09:32,017 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 36 interpolants. [2018-11-23 12:09:32,018 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=630, Invalid=630, Unknown=0, NotChecked=0, Total=1260 [2018-11-23 12:09:32,018 INFO L87 Difference]: Start difference. First operand 56 states and 58 transitions. Second operand 36 states. [2018-11-23 12:09:33,216 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:33,216 INFO L93 Difference]: Finished difference Result 104 states and 120 transitions. [2018-11-23 12:09:33,216 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 36 states. [2018-11-23 12:09:33,216 INFO L78 Accepts]: Start accepts. Automaton has 36 states. Word has length 52 [2018-11-23 12:09:33,216 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:33,217 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 36 states. [2018-11-23 12:09:33,218 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 36 states to 36 states and 113 transitions. [2018-11-23 12:09:33,219 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 36 states. [2018-11-23 12:09:33,220 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 36 states to 36 states and 113 transitions. [2018-11-23 12:09:33,221 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 36 states and 113 transitions. [2018-11-23 12:09:33,434 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 113 edges. 113 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:33,436 INFO L225 Difference]: With dead ends: 104 [2018-11-23 12:09:33,436 INFO L226 Difference]: Without dead ends: 85 [2018-11-23 12:09:33,437 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 84 GetRequests, 50 SyntacticMatches, 0 SemanticMatches, 34 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 1.6s TimeCoverageRelationStatistics Valid=630, Invalid=630, Unknown=0, NotChecked=0, Total=1260 [2018-11-23 12:09:33,437 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 85 states. [2018-11-23 12:09:33,483 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 85 to 61. [2018-11-23 12:09:33,483 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:33,484 INFO L82 GeneralOperation]: Start isEquivalent. First operand 85 states. Second operand 61 states. [2018-11-23 12:09:33,484 INFO L74 IsIncluded]: Start isIncluded. First operand 85 states. Second operand 61 states. [2018-11-23 12:09:33,484 INFO L87 Difference]: Start difference. First operand 85 states. Second operand 61 states. [2018-11-23 12:09:33,486 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:33,486 INFO L93 Difference]: Finished difference Result 85 states and 95 transitions. [2018-11-23 12:09:33,487 INFO L276 IsEmpty]: Start isEmpty. Operand 85 states and 95 transitions. [2018-11-23 12:09:33,487 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:33,487 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:33,488 INFO L74 IsIncluded]: Start isIncluded. First operand 61 states. Second operand 85 states. [2018-11-23 12:09:33,488 INFO L87 Difference]: Start difference. First operand 61 states. Second operand 85 states. [2018-11-23 12:09:33,489 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:33,490 INFO L93 Difference]: Finished difference Result 85 states and 95 transitions. [2018-11-23 12:09:33,490 INFO L276 IsEmpty]: Start isEmpty. Operand 85 states and 95 transitions. [2018-11-23 12:09:33,490 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:33,490 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:33,491 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:33,491 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:33,491 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 61 states. [2018-11-23 12:09:33,492 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 61 states to 61 states and 63 transitions. [2018-11-23 12:09:33,492 INFO L78 Accepts]: Start accepts. Automaton has 61 states and 63 transitions. Word has length 52 [2018-11-23 12:09:33,492 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:33,492 INFO L480 AbstractCegarLoop]: Abstraction has 61 states and 63 transitions. [2018-11-23 12:09:33,492 INFO L481 AbstractCegarLoop]: Interpolant automaton has 36 states. [2018-11-23 12:09:33,492 INFO L276 IsEmpty]: Start isEmpty. Operand 61 states and 63 transitions. [2018-11-23 12:09:33,493 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 58 [2018-11-23 12:09:33,493 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:33,493 INFO L402 BasicCegarLoop]: trace histogram [34, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:33,493 INFO L423 AbstractCegarLoop]: === Iteration 22 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:33,494 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:33,494 INFO L82 PathProgramCache]: Analyzing trace with hash 781842854, now seen corresponding path program 19 times [2018-11-23 12:09:33,494 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:33,494 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:33,495 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:33,495 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:33,495 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:33,527 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:34,275 INFO L256 TraceCheckUtils]: 0: Hoare triple {7342#true} call ULTIMATE.init(); {7342#true} is VALID [2018-11-23 12:09:34,276 INFO L273 TraceCheckUtils]: 1: Hoare triple {7342#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {7342#true} is VALID [2018-11-23 12:09:34,276 INFO L273 TraceCheckUtils]: 2: Hoare triple {7342#true} assume true; {7342#true} is VALID [2018-11-23 12:09:34,276 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {7342#true} {7342#true} #60#return; {7342#true} is VALID [2018-11-23 12:09:34,276 INFO L256 TraceCheckUtils]: 4: Hoare triple {7342#true} call #t~ret4 := main(); {7342#true} is VALID [2018-11-23 12:09:34,277 INFO L273 TraceCheckUtils]: 5: Hoare triple {7342#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; {7344#(= main_~i~0 0)} is VALID [2018-11-23 12:09:34,278 INFO L273 TraceCheckUtils]: 6: Hoare triple {7344#(= 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; {7345#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:34,279 INFO L273 TraceCheckUtils]: 7: Hoare triple {7345#(<= 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; {7346#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:34,279 INFO L273 TraceCheckUtils]: 8: Hoare triple {7346#(<= 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; {7347#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:34,280 INFO L273 TraceCheckUtils]: 9: Hoare triple {7347#(<= 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; {7348#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:34,281 INFO L273 TraceCheckUtils]: 10: Hoare triple {7348#(<= 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; {7349#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:34,282 INFO L273 TraceCheckUtils]: 11: Hoare triple {7349#(<= 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; {7350#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:34,283 INFO L273 TraceCheckUtils]: 12: Hoare triple {7350#(<= 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; {7351#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:34,284 INFO L273 TraceCheckUtils]: 13: Hoare triple {7351#(<= 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; {7352#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:34,285 INFO L273 TraceCheckUtils]: 14: Hoare triple {7352#(<= 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; {7353#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:34,286 INFO L273 TraceCheckUtils]: 15: Hoare triple {7353#(<= 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; {7354#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:34,287 INFO L273 TraceCheckUtils]: 16: Hoare triple {7354#(<= 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; {7355#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:34,288 INFO L273 TraceCheckUtils]: 17: Hoare triple {7355#(<= 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; {7356#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:34,289 INFO L273 TraceCheckUtils]: 18: Hoare triple {7356#(<= 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; {7357#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:34,290 INFO L273 TraceCheckUtils]: 19: Hoare triple {7357#(<= 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; {7358#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:34,291 INFO L273 TraceCheckUtils]: 20: Hoare triple {7358#(<= 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; {7359#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:34,292 INFO L273 TraceCheckUtils]: 21: Hoare triple {7359#(<= 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; {7360#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:34,293 INFO L273 TraceCheckUtils]: 22: Hoare triple {7360#(<= 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; {7361#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:34,294 INFO L273 TraceCheckUtils]: 23: Hoare triple {7361#(<= 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; {7362#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:34,295 INFO L273 TraceCheckUtils]: 24: Hoare triple {7362#(<= 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; {7363#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:34,296 INFO L273 TraceCheckUtils]: 25: Hoare triple {7363#(<= 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; {7364#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:34,297 INFO L273 TraceCheckUtils]: 26: Hoare triple {7364#(<= 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; {7365#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:34,298 INFO L273 TraceCheckUtils]: 27: Hoare triple {7365#(<= 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; {7366#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:34,299 INFO L273 TraceCheckUtils]: 28: Hoare triple {7366#(<= 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; {7367#(<= main_~i~0 23)} is VALID [2018-11-23 12:09:34,300 INFO L273 TraceCheckUtils]: 29: Hoare triple {7367#(<= 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; {7368#(<= main_~i~0 24)} is VALID [2018-11-23 12:09:34,301 INFO L273 TraceCheckUtils]: 30: Hoare triple {7368#(<= 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; {7369#(<= main_~i~0 25)} is VALID [2018-11-23 12:09:34,302 INFO L273 TraceCheckUtils]: 31: Hoare triple {7369#(<= 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; {7370#(<= main_~i~0 26)} is VALID [2018-11-23 12:09:34,303 INFO L273 TraceCheckUtils]: 32: Hoare triple {7370#(<= 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; {7371#(<= main_~i~0 27)} is VALID [2018-11-23 12:09:34,304 INFO L273 TraceCheckUtils]: 33: Hoare triple {7371#(<= 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; {7372#(<= main_~i~0 28)} is VALID [2018-11-23 12:09:34,305 INFO L273 TraceCheckUtils]: 34: Hoare triple {7372#(<= 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; {7373#(<= main_~i~0 29)} is VALID [2018-11-23 12:09:34,306 INFO L273 TraceCheckUtils]: 35: Hoare triple {7373#(<= 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; {7374#(<= main_~i~0 30)} is VALID [2018-11-23 12:09:34,307 INFO L273 TraceCheckUtils]: 36: Hoare triple {7374#(<= 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; {7375#(<= main_~i~0 31)} is VALID [2018-11-23 12:09:34,308 INFO L273 TraceCheckUtils]: 37: Hoare triple {7375#(<= 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; {7376#(<= main_~i~0 32)} is VALID [2018-11-23 12:09:34,309 INFO L273 TraceCheckUtils]: 38: Hoare triple {7376#(<= 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; {7377#(<= main_~i~0 33)} is VALID [2018-11-23 12:09:34,310 INFO L273 TraceCheckUtils]: 39: Hoare triple {7377#(<= 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; {7378#(<= main_~i~0 34)} is VALID [2018-11-23 12:09:34,311 INFO L273 TraceCheckUtils]: 40: Hoare triple {7378#(<= main_~i~0 34)} assume !(~i~0 < 100000); {7343#false} is VALID [2018-11-23 12:09:34,311 INFO L273 TraceCheckUtils]: 41: Hoare triple {7343#false} ~i~0 := 1; {7343#false} is VALID [2018-11-23 12:09:34,311 INFO L273 TraceCheckUtils]: 42: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,312 INFO L273 TraceCheckUtils]: 43: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,312 INFO L273 TraceCheckUtils]: 44: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,312 INFO L273 TraceCheckUtils]: 45: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,312 INFO L273 TraceCheckUtils]: 46: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,312 INFO L273 TraceCheckUtils]: 47: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,313 INFO L273 TraceCheckUtils]: 48: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,313 INFO L273 TraceCheckUtils]: 49: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,313 INFO L273 TraceCheckUtils]: 50: Hoare triple {7343#false} assume !(~i~0 < 100000); {7343#false} is VALID [2018-11-23 12:09:34,313 INFO L273 TraceCheckUtils]: 51: Hoare triple {7343#false} ~i~0 := 1;~j~0 := 0; {7343#false} is VALID [2018-11-23 12:09:34,313 INFO L273 TraceCheckUtils]: 52: Hoare triple {7343#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 + 7 * ~j~0), 4); {7343#false} is VALID [2018-11-23 12:09:34,314 INFO L256 TraceCheckUtils]: 53: Hoare triple {7343#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {7343#false} is VALID [2018-11-23 12:09:34,314 INFO L273 TraceCheckUtils]: 54: Hoare triple {7343#false} ~cond := #in~cond; {7343#false} is VALID [2018-11-23 12:09:34,314 INFO L273 TraceCheckUtils]: 55: Hoare triple {7343#false} assume 0 == ~cond; {7343#false} is VALID [2018-11-23 12:09:34,314 INFO L273 TraceCheckUtils]: 56: Hoare triple {7343#false} assume !false; {7343#false} is VALID [2018-11-23 12:09:34,317 INFO L134 CoverageAnalysis]: Checked inductivity of 631 backedges. 0 proven. 595 refuted. 0 times theorem prover too weak. 36 trivial. 0 not checked. [2018-11-23 12:09:34,317 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:34,317 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:09:34,327 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:34,379 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:34,400 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:34,401 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:34,672 INFO L256 TraceCheckUtils]: 0: Hoare triple {7342#true} call ULTIMATE.init(); {7342#true} is VALID [2018-11-23 12:09:34,672 INFO L273 TraceCheckUtils]: 1: Hoare triple {7342#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {7342#true} is VALID [2018-11-23 12:09:34,672 INFO L273 TraceCheckUtils]: 2: Hoare triple {7342#true} assume true; {7342#true} is VALID [2018-11-23 12:09:34,672 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {7342#true} {7342#true} #60#return; {7342#true} is VALID [2018-11-23 12:09:34,673 INFO L256 TraceCheckUtils]: 4: Hoare triple {7342#true} call #t~ret4 := main(); {7342#true} is VALID [2018-11-23 12:09:34,673 INFO L273 TraceCheckUtils]: 5: Hoare triple {7342#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; {7397#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:34,674 INFO L273 TraceCheckUtils]: 6: Hoare triple {7397#(<= 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; {7345#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:34,674 INFO L273 TraceCheckUtils]: 7: Hoare triple {7345#(<= 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; {7346#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:34,675 INFO L273 TraceCheckUtils]: 8: Hoare triple {7346#(<= 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; {7347#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:34,676 INFO L273 TraceCheckUtils]: 9: Hoare triple {7347#(<= 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; {7348#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:34,676 INFO L273 TraceCheckUtils]: 10: Hoare triple {7348#(<= 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; {7349#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:34,677 INFO L273 TraceCheckUtils]: 11: Hoare triple {7349#(<= 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; {7350#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:34,678 INFO L273 TraceCheckUtils]: 12: Hoare triple {7350#(<= 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; {7351#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:34,679 INFO L273 TraceCheckUtils]: 13: Hoare triple {7351#(<= 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; {7352#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:34,680 INFO L273 TraceCheckUtils]: 14: Hoare triple {7352#(<= 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; {7353#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:34,681 INFO L273 TraceCheckUtils]: 15: Hoare triple {7353#(<= 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; {7354#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:34,682 INFO L273 TraceCheckUtils]: 16: Hoare triple {7354#(<= 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; {7355#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:34,683 INFO L273 TraceCheckUtils]: 17: Hoare triple {7355#(<= 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; {7356#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:34,684 INFO L273 TraceCheckUtils]: 18: Hoare triple {7356#(<= 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; {7357#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:34,685 INFO L273 TraceCheckUtils]: 19: Hoare triple {7357#(<= 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; {7358#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:34,686 INFO L273 TraceCheckUtils]: 20: Hoare triple {7358#(<= 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; {7359#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:34,687 INFO L273 TraceCheckUtils]: 21: Hoare triple {7359#(<= 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; {7360#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:34,688 INFO L273 TraceCheckUtils]: 22: Hoare triple {7360#(<= 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; {7361#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:34,689 INFO L273 TraceCheckUtils]: 23: Hoare triple {7361#(<= 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; {7362#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:34,690 INFO L273 TraceCheckUtils]: 24: Hoare triple {7362#(<= 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; {7363#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:34,691 INFO L273 TraceCheckUtils]: 25: Hoare triple {7363#(<= 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; {7364#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:34,692 INFO L273 TraceCheckUtils]: 26: Hoare triple {7364#(<= 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; {7365#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:34,693 INFO L273 TraceCheckUtils]: 27: Hoare triple {7365#(<= 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; {7366#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:34,694 INFO L273 TraceCheckUtils]: 28: Hoare triple {7366#(<= 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; {7367#(<= main_~i~0 23)} is VALID [2018-11-23 12:09:34,695 INFO L273 TraceCheckUtils]: 29: Hoare triple {7367#(<= 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; {7368#(<= main_~i~0 24)} is VALID [2018-11-23 12:09:34,696 INFO L273 TraceCheckUtils]: 30: Hoare triple {7368#(<= 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; {7369#(<= main_~i~0 25)} is VALID [2018-11-23 12:09:34,698 INFO L273 TraceCheckUtils]: 31: Hoare triple {7369#(<= 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; {7370#(<= main_~i~0 26)} is VALID [2018-11-23 12:09:34,699 INFO L273 TraceCheckUtils]: 32: Hoare triple {7370#(<= 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; {7371#(<= main_~i~0 27)} is VALID [2018-11-23 12:09:34,700 INFO L273 TraceCheckUtils]: 33: Hoare triple {7371#(<= 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; {7372#(<= main_~i~0 28)} is VALID [2018-11-23 12:09:34,701 INFO L273 TraceCheckUtils]: 34: Hoare triple {7372#(<= 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; {7373#(<= main_~i~0 29)} is VALID [2018-11-23 12:09:34,702 INFO L273 TraceCheckUtils]: 35: Hoare triple {7373#(<= 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; {7374#(<= main_~i~0 30)} is VALID [2018-11-23 12:09:34,703 INFO L273 TraceCheckUtils]: 36: Hoare triple {7374#(<= 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; {7375#(<= main_~i~0 31)} is VALID [2018-11-23 12:09:34,704 INFO L273 TraceCheckUtils]: 37: Hoare triple {7375#(<= 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; {7376#(<= main_~i~0 32)} is VALID [2018-11-23 12:09:34,705 INFO L273 TraceCheckUtils]: 38: Hoare triple {7376#(<= 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; {7377#(<= main_~i~0 33)} is VALID [2018-11-23 12:09:34,706 INFO L273 TraceCheckUtils]: 39: Hoare triple {7377#(<= 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; {7378#(<= main_~i~0 34)} is VALID [2018-11-23 12:09:34,706 INFO L273 TraceCheckUtils]: 40: Hoare triple {7378#(<= main_~i~0 34)} assume !(~i~0 < 100000); {7343#false} is VALID [2018-11-23 12:09:34,707 INFO L273 TraceCheckUtils]: 41: Hoare triple {7343#false} ~i~0 := 1; {7343#false} is VALID [2018-11-23 12:09:34,707 INFO L273 TraceCheckUtils]: 42: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,707 INFO L273 TraceCheckUtils]: 43: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,707 INFO L273 TraceCheckUtils]: 44: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,707 INFO L273 TraceCheckUtils]: 45: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,708 INFO L273 TraceCheckUtils]: 46: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,708 INFO L273 TraceCheckUtils]: 47: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,708 INFO L273 TraceCheckUtils]: 48: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,708 INFO L273 TraceCheckUtils]: 49: Hoare triple {7343#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7343#false} is VALID [2018-11-23 12:09:34,708 INFO L273 TraceCheckUtils]: 50: Hoare triple {7343#false} assume !(~i~0 < 100000); {7343#false} is VALID [2018-11-23 12:09:34,709 INFO L273 TraceCheckUtils]: 51: Hoare triple {7343#false} ~i~0 := 1;~j~0 := 0; {7343#false} is VALID [2018-11-23 12:09:34,709 INFO L273 TraceCheckUtils]: 52: Hoare triple {7343#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 + 7 * ~j~0), 4); {7343#false} is VALID [2018-11-23 12:09:34,709 INFO L256 TraceCheckUtils]: 53: Hoare triple {7343#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {7343#false} is VALID [2018-11-23 12:09:34,709 INFO L273 TraceCheckUtils]: 54: Hoare triple {7343#false} ~cond := #in~cond; {7343#false} is VALID [2018-11-23 12:09:34,709 INFO L273 TraceCheckUtils]: 55: Hoare triple {7343#false} assume 0 == ~cond; {7343#false} is VALID [2018-11-23 12:09:34,709 INFO L273 TraceCheckUtils]: 56: Hoare triple {7343#false} assume !false; {7343#false} is VALID [2018-11-23 12:09:34,712 INFO L134 CoverageAnalysis]: Checked inductivity of 631 backedges. 0 proven. 595 refuted. 0 times theorem prover too weak. 36 trivial. 0 not checked. [2018-11-23 12:09:34,732 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:34,732 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [37, 37] total 38 [2018-11-23 12:09:34,733 INFO L78 Accepts]: Start accepts. Automaton has 38 states. Word has length 57 [2018-11-23 12:09:34,733 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:34,733 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 38 states. [2018-11-23 12:09:34,772 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:34,773 INFO L459 AbstractCegarLoop]: Interpolant automaton has 38 states [2018-11-23 12:09:34,773 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 38 interpolants. [2018-11-23 12:09:34,774 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=703, Invalid=703, Unknown=0, NotChecked=0, Total=1406 [2018-11-23 12:09:34,774 INFO L87 Difference]: Start difference. First operand 61 states and 63 transitions. Second operand 38 states. [2018-11-23 12:09:36,346 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:36,346 INFO L93 Difference]: Finished difference Result 97 states and 106 transitions. [2018-11-23 12:09:36,346 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 37 states. [2018-11-23 12:09:36,347 INFO L78 Accepts]: Start accepts. Automaton has 38 states. Word has length 57 [2018-11-23 12:09:36,347 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:36,347 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 38 states. [2018-11-23 12:09:36,349 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 37 states to 37 states and 95 transitions. [2018-11-23 12:09:36,349 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 38 states. [2018-11-23 12:09:36,350 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 37 states to 37 states and 95 transitions. [2018-11-23 12:09:36,350 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 37 states and 95 transitions. [2018-11-23 12:09:36,486 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 95 edges. 95 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:36,488 INFO L225 Difference]: With dead ends: 97 [2018-11-23 12:09:36,488 INFO L226 Difference]: Without dead ends: 77 [2018-11-23 12:09:36,489 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 93 GetRequests, 57 SyntacticMatches, 0 SemanticMatches, 36 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 66 ImplicationChecksByTransitivity, 0.6s TimeCoverageRelationStatistics Valid=703, Invalid=703, Unknown=0, NotChecked=0, Total=1406 [2018-11-23 12:09:36,489 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 77 states. [2018-11-23 12:09:36,541 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 77 to 62. [2018-11-23 12:09:36,542 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:36,542 INFO L82 GeneralOperation]: Start isEquivalent. First operand 77 states. Second operand 62 states. [2018-11-23 12:09:36,542 INFO L74 IsIncluded]: Start isIncluded. First operand 77 states. Second operand 62 states. [2018-11-23 12:09:36,542 INFO L87 Difference]: Start difference. First operand 77 states. Second operand 62 states. [2018-11-23 12:09:36,545 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:36,545 INFO L93 Difference]: Finished difference Result 77 states and 84 transitions. [2018-11-23 12:09:36,545 INFO L276 IsEmpty]: Start isEmpty. Operand 77 states and 84 transitions. [2018-11-23 12:09:36,546 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:36,546 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:36,546 INFO L74 IsIncluded]: Start isIncluded. First operand 62 states. Second operand 77 states. [2018-11-23 12:09:36,546 INFO L87 Difference]: Start difference. First operand 62 states. Second operand 77 states. [2018-11-23 12:09:36,548 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:36,548 INFO L93 Difference]: Finished difference Result 77 states and 84 transitions. [2018-11-23 12:09:36,548 INFO L276 IsEmpty]: Start isEmpty. Operand 77 states and 84 transitions. [2018-11-23 12:09:36,549 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:36,549 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:36,549 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:36,549 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:36,549 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 62 states. [2018-11-23 12:09:36,550 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 62 states to 62 states and 64 transitions. [2018-11-23 12:09:36,550 INFO L78 Accepts]: Start accepts. Automaton has 62 states and 64 transitions. Word has length 57 [2018-11-23 12:09:36,551 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:36,551 INFO L480 AbstractCegarLoop]: Abstraction has 62 states and 64 transitions. [2018-11-23 12:09:36,551 INFO L481 AbstractCegarLoop]: Interpolant automaton has 38 states. [2018-11-23 12:09:36,551 INFO L276 IsEmpty]: Start isEmpty. Operand 62 states and 64 transitions. [2018-11-23 12:09:36,551 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 59 [2018-11-23 12:09:36,551 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:36,552 INFO L402 BasicCegarLoop]: trace histogram [35, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:36,552 INFO L423 AbstractCegarLoop]: === Iteration 23 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:36,552 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:36,552 INFO L82 PathProgramCache]: Analyzing trace with hash -579796790, now seen corresponding path program 20 times [2018-11-23 12:09:36,552 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:36,552 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:36,553 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:36,553 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:36,553 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:36,589 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:37,369 INFO L256 TraceCheckUtils]: 0: Hoare triple {7989#true} call ULTIMATE.init(); {7989#true} is VALID [2018-11-23 12:09:37,370 INFO L273 TraceCheckUtils]: 1: Hoare triple {7989#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {7989#true} is VALID [2018-11-23 12:09:37,370 INFO L273 TraceCheckUtils]: 2: Hoare triple {7989#true} assume true; {7989#true} is VALID [2018-11-23 12:09:37,370 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {7989#true} {7989#true} #60#return; {7989#true} is VALID [2018-11-23 12:09:37,370 INFO L256 TraceCheckUtils]: 4: Hoare triple {7989#true} call #t~ret4 := main(); {7989#true} is VALID [2018-11-23 12:09:37,371 INFO L273 TraceCheckUtils]: 5: Hoare triple {7989#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; {7991#(= main_~i~0 0)} is VALID [2018-11-23 12:09:37,372 INFO L273 TraceCheckUtils]: 6: Hoare triple {7991#(= 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; {7992#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:37,373 INFO L273 TraceCheckUtils]: 7: Hoare triple {7992#(<= 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; {7993#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:37,374 INFO L273 TraceCheckUtils]: 8: Hoare triple {7993#(<= 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; {7994#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:37,375 INFO L273 TraceCheckUtils]: 9: Hoare triple {7994#(<= 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; {7995#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:37,375 INFO L273 TraceCheckUtils]: 10: Hoare triple {7995#(<= 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; {7996#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:37,376 INFO L273 TraceCheckUtils]: 11: Hoare triple {7996#(<= 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; {7997#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:37,377 INFO L273 TraceCheckUtils]: 12: Hoare triple {7997#(<= 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; {7998#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:37,378 INFO L273 TraceCheckUtils]: 13: Hoare triple {7998#(<= 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; {7999#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:37,379 INFO L273 TraceCheckUtils]: 14: Hoare triple {7999#(<= 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; {8000#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:37,380 INFO L273 TraceCheckUtils]: 15: Hoare triple {8000#(<= 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; {8001#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:37,381 INFO L273 TraceCheckUtils]: 16: Hoare triple {8001#(<= 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; {8002#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:37,400 INFO L273 TraceCheckUtils]: 17: Hoare triple {8002#(<= 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; {8003#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:37,401 INFO L273 TraceCheckUtils]: 18: Hoare triple {8003#(<= 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; {8004#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:37,402 INFO L273 TraceCheckUtils]: 19: Hoare triple {8004#(<= 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; {8005#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:37,402 INFO L273 TraceCheckUtils]: 20: Hoare triple {8005#(<= 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; {8006#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:37,403 INFO L273 TraceCheckUtils]: 21: Hoare triple {8006#(<= 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; {8007#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:37,404 INFO L273 TraceCheckUtils]: 22: Hoare triple {8007#(<= 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; {8008#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:37,404 INFO L273 TraceCheckUtils]: 23: Hoare triple {8008#(<= 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; {8009#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:37,405 INFO L273 TraceCheckUtils]: 24: Hoare triple {8009#(<= 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; {8010#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:37,406 INFO L273 TraceCheckUtils]: 25: Hoare triple {8010#(<= 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; {8011#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:37,407 INFO L273 TraceCheckUtils]: 26: Hoare triple {8011#(<= 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; {8012#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:37,408 INFO L273 TraceCheckUtils]: 27: Hoare triple {8012#(<= 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; {8013#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:37,409 INFO L273 TraceCheckUtils]: 28: Hoare triple {8013#(<= 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; {8014#(<= main_~i~0 23)} is VALID [2018-11-23 12:09:37,410 INFO L273 TraceCheckUtils]: 29: Hoare triple {8014#(<= 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; {8015#(<= main_~i~0 24)} is VALID [2018-11-23 12:09:37,411 INFO L273 TraceCheckUtils]: 30: Hoare triple {8015#(<= 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; {8016#(<= main_~i~0 25)} is VALID [2018-11-23 12:09:37,412 INFO L273 TraceCheckUtils]: 31: Hoare triple {8016#(<= 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; {8017#(<= main_~i~0 26)} is VALID [2018-11-23 12:09:37,413 INFO L273 TraceCheckUtils]: 32: Hoare triple {8017#(<= 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; {8018#(<= main_~i~0 27)} is VALID [2018-11-23 12:09:37,414 INFO L273 TraceCheckUtils]: 33: Hoare triple {8018#(<= 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; {8019#(<= main_~i~0 28)} is VALID [2018-11-23 12:09:37,415 INFO L273 TraceCheckUtils]: 34: Hoare triple {8019#(<= 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; {8020#(<= main_~i~0 29)} is VALID [2018-11-23 12:09:37,416 INFO L273 TraceCheckUtils]: 35: Hoare triple {8020#(<= 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; {8021#(<= main_~i~0 30)} is VALID [2018-11-23 12:09:37,417 INFO L273 TraceCheckUtils]: 36: Hoare triple {8021#(<= 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; {8022#(<= main_~i~0 31)} is VALID [2018-11-23 12:09:37,418 INFO L273 TraceCheckUtils]: 37: Hoare triple {8022#(<= 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; {8023#(<= main_~i~0 32)} is VALID [2018-11-23 12:09:37,419 INFO L273 TraceCheckUtils]: 38: Hoare triple {8023#(<= 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; {8024#(<= main_~i~0 33)} is VALID [2018-11-23 12:09:37,420 INFO L273 TraceCheckUtils]: 39: Hoare triple {8024#(<= 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; {8025#(<= main_~i~0 34)} is VALID [2018-11-23 12:09:37,421 INFO L273 TraceCheckUtils]: 40: Hoare triple {8025#(<= 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; {8026#(<= main_~i~0 35)} is VALID [2018-11-23 12:09:37,421 INFO L273 TraceCheckUtils]: 41: Hoare triple {8026#(<= main_~i~0 35)} assume !(~i~0 < 100000); {7990#false} is VALID [2018-11-23 12:09:37,422 INFO L273 TraceCheckUtils]: 42: Hoare triple {7990#false} ~i~0 := 1; {7990#false} is VALID [2018-11-23 12:09:37,422 INFO L273 TraceCheckUtils]: 43: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:37,422 INFO L273 TraceCheckUtils]: 44: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:37,422 INFO L273 TraceCheckUtils]: 45: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:37,423 INFO L273 TraceCheckUtils]: 46: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:37,423 INFO L273 TraceCheckUtils]: 47: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:37,423 INFO L273 TraceCheckUtils]: 48: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:37,423 INFO L273 TraceCheckUtils]: 49: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:37,423 INFO L273 TraceCheckUtils]: 50: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:37,424 INFO L273 TraceCheckUtils]: 51: Hoare triple {7990#false} assume !(~i~0 < 100000); {7990#false} is VALID [2018-11-23 12:09:37,424 INFO L273 TraceCheckUtils]: 52: Hoare triple {7990#false} ~i~0 := 1;~j~0 := 0; {7990#false} is VALID [2018-11-23 12:09:37,424 INFO L273 TraceCheckUtils]: 53: Hoare triple {7990#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 + 7 * ~j~0), 4); {7990#false} is VALID [2018-11-23 12:09:37,424 INFO L256 TraceCheckUtils]: 54: Hoare triple {7990#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {7990#false} is VALID [2018-11-23 12:09:37,424 INFO L273 TraceCheckUtils]: 55: Hoare triple {7990#false} ~cond := #in~cond; {7990#false} is VALID [2018-11-23 12:09:37,425 INFO L273 TraceCheckUtils]: 56: Hoare triple {7990#false} assume 0 == ~cond; {7990#false} is VALID [2018-11-23 12:09:37,425 INFO L273 TraceCheckUtils]: 57: Hoare triple {7990#false} assume !false; {7990#false} is VALID [2018-11-23 12:09:37,428 INFO L134 CoverageAnalysis]: Checked inductivity of 666 backedges. 0 proven. 630 refuted. 0 times theorem prover too weak. 36 trivial. 0 not checked. [2018-11-23 12:09:37,428 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:37,428 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:09:37,437 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:09:37,487 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:09:37,487 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:37,505 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:37,506 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:37,964 INFO L256 TraceCheckUtils]: 0: Hoare triple {7989#true} call ULTIMATE.init(); {7989#true} is VALID [2018-11-23 12:09:37,964 INFO L273 TraceCheckUtils]: 1: Hoare triple {7989#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {7989#true} is VALID [2018-11-23 12:09:37,964 INFO L273 TraceCheckUtils]: 2: Hoare triple {7989#true} assume true; {7989#true} is VALID [2018-11-23 12:09:37,964 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {7989#true} {7989#true} #60#return; {7989#true} is VALID [2018-11-23 12:09:37,964 INFO L256 TraceCheckUtils]: 4: Hoare triple {7989#true} call #t~ret4 := main(); {7989#true} is VALID [2018-11-23 12:09:37,965 INFO L273 TraceCheckUtils]: 5: Hoare triple {7989#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; {8045#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:37,966 INFO L273 TraceCheckUtils]: 6: Hoare triple {8045#(<= 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; {7992#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:37,966 INFO L273 TraceCheckUtils]: 7: Hoare triple {7992#(<= 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; {7993#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:37,968 INFO L273 TraceCheckUtils]: 8: Hoare triple {7993#(<= 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; {7994#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:37,968 INFO L273 TraceCheckUtils]: 9: Hoare triple {7994#(<= 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; {7995#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:37,969 INFO L273 TraceCheckUtils]: 10: Hoare triple {7995#(<= 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; {7996#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:37,970 INFO L273 TraceCheckUtils]: 11: Hoare triple {7996#(<= 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; {7997#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:37,971 INFO L273 TraceCheckUtils]: 12: Hoare triple {7997#(<= 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; {7998#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:37,972 INFO L273 TraceCheckUtils]: 13: Hoare triple {7998#(<= 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; {7999#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:37,973 INFO L273 TraceCheckUtils]: 14: Hoare triple {7999#(<= 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; {8000#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:37,974 INFO L273 TraceCheckUtils]: 15: Hoare triple {8000#(<= 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; {8001#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:37,975 INFO L273 TraceCheckUtils]: 16: Hoare triple {8001#(<= 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; {8002#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:37,976 INFO L273 TraceCheckUtils]: 17: Hoare triple {8002#(<= 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; {8003#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:37,977 INFO L273 TraceCheckUtils]: 18: Hoare triple {8003#(<= 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; {8004#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:37,978 INFO L273 TraceCheckUtils]: 19: Hoare triple {8004#(<= 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; {8005#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:37,979 INFO L273 TraceCheckUtils]: 20: Hoare triple {8005#(<= 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; {8006#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:37,980 INFO L273 TraceCheckUtils]: 21: Hoare triple {8006#(<= 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; {8007#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:37,981 INFO L273 TraceCheckUtils]: 22: Hoare triple {8007#(<= 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; {8008#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:37,982 INFO L273 TraceCheckUtils]: 23: Hoare triple {8008#(<= 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; {8009#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:37,984 INFO L273 TraceCheckUtils]: 24: Hoare triple {8009#(<= 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; {8010#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:37,985 INFO L273 TraceCheckUtils]: 25: Hoare triple {8010#(<= 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; {8011#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:37,986 INFO L273 TraceCheckUtils]: 26: Hoare triple {8011#(<= 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; {8012#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:37,986 INFO L273 TraceCheckUtils]: 27: Hoare triple {8012#(<= 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; {8013#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:37,987 INFO L273 TraceCheckUtils]: 28: Hoare triple {8013#(<= 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; {8014#(<= main_~i~0 23)} is VALID [2018-11-23 12:09:37,988 INFO L273 TraceCheckUtils]: 29: Hoare triple {8014#(<= 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; {8015#(<= main_~i~0 24)} is VALID [2018-11-23 12:09:37,988 INFO L273 TraceCheckUtils]: 30: Hoare triple {8015#(<= 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; {8016#(<= main_~i~0 25)} is VALID [2018-11-23 12:09:37,989 INFO L273 TraceCheckUtils]: 31: Hoare triple {8016#(<= 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; {8017#(<= main_~i~0 26)} is VALID [2018-11-23 12:09:37,990 INFO L273 TraceCheckUtils]: 32: Hoare triple {8017#(<= 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; {8018#(<= main_~i~0 27)} is VALID [2018-11-23 12:09:37,991 INFO L273 TraceCheckUtils]: 33: Hoare triple {8018#(<= 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; {8019#(<= main_~i~0 28)} is VALID [2018-11-23 12:09:37,992 INFO L273 TraceCheckUtils]: 34: Hoare triple {8019#(<= 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; {8020#(<= main_~i~0 29)} is VALID [2018-11-23 12:09:37,993 INFO L273 TraceCheckUtils]: 35: Hoare triple {8020#(<= 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; {8021#(<= main_~i~0 30)} is VALID [2018-11-23 12:09:37,994 INFO L273 TraceCheckUtils]: 36: Hoare triple {8021#(<= 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; {8022#(<= main_~i~0 31)} is VALID [2018-11-23 12:09:37,995 INFO L273 TraceCheckUtils]: 37: Hoare triple {8022#(<= 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; {8023#(<= main_~i~0 32)} is VALID [2018-11-23 12:09:37,996 INFO L273 TraceCheckUtils]: 38: Hoare triple {8023#(<= 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; {8024#(<= main_~i~0 33)} is VALID [2018-11-23 12:09:37,997 INFO L273 TraceCheckUtils]: 39: Hoare triple {8024#(<= 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; {8025#(<= main_~i~0 34)} is VALID [2018-11-23 12:09:37,998 INFO L273 TraceCheckUtils]: 40: Hoare triple {8025#(<= 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; {8026#(<= main_~i~0 35)} is VALID [2018-11-23 12:09:37,999 INFO L273 TraceCheckUtils]: 41: Hoare triple {8026#(<= main_~i~0 35)} assume !(~i~0 < 100000); {7990#false} is VALID [2018-11-23 12:09:37,999 INFO L273 TraceCheckUtils]: 42: Hoare triple {7990#false} ~i~0 := 1; {7990#false} is VALID [2018-11-23 12:09:38,000 INFO L273 TraceCheckUtils]: 43: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:38,000 INFO L273 TraceCheckUtils]: 44: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:38,000 INFO L273 TraceCheckUtils]: 45: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:38,000 INFO L273 TraceCheckUtils]: 46: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:38,000 INFO L273 TraceCheckUtils]: 47: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:38,001 INFO L273 TraceCheckUtils]: 48: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:38,001 INFO L273 TraceCheckUtils]: 49: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:38,001 INFO L273 TraceCheckUtils]: 50: Hoare triple {7990#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {7990#false} is VALID [2018-11-23 12:09:38,001 INFO L273 TraceCheckUtils]: 51: Hoare triple {7990#false} assume !(~i~0 < 100000); {7990#false} is VALID [2018-11-23 12:09:38,001 INFO L273 TraceCheckUtils]: 52: Hoare triple {7990#false} ~i~0 := 1;~j~0 := 0; {7990#false} is VALID [2018-11-23 12:09:38,002 INFO L273 TraceCheckUtils]: 53: Hoare triple {7990#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 + 7 * ~j~0), 4); {7990#false} is VALID [2018-11-23 12:09:38,002 INFO L256 TraceCheckUtils]: 54: Hoare triple {7990#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {7990#false} is VALID [2018-11-23 12:09:38,002 INFO L273 TraceCheckUtils]: 55: Hoare triple {7990#false} ~cond := #in~cond; {7990#false} is VALID [2018-11-23 12:09:38,002 INFO L273 TraceCheckUtils]: 56: Hoare triple {7990#false} assume 0 == ~cond; {7990#false} is VALID [2018-11-23 12:09:38,002 INFO L273 TraceCheckUtils]: 57: Hoare triple {7990#false} assume !false; {7990#false} is VALID [2018-11-23 12:09:38,005 INFO L134 CoverageAnalysis]: Checked inductivity of 666 backedges. 0 proven. 630 refuted. 0 times theorem prover too weak. 36 trivial. 0 not checked. [2018-11-23 12:09:38,025 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:38,025 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [38, 38] total 39 [2018-11-23 12:09:38,025 INFO L78 Accepts]: Start accepts. Automaton has 39 states. Word has length 58 [2018-11-23 12:09:38,025 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:38,026 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 39 states. [2018-11-23 12:09:38,068 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 53 edges. 53 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:38,069 INFO L459 AbstractCegarLoop]: Interpolant automaton has 39 states [2018-11-23 12:09:38,069 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 39 interpolants. [2018-11-23 12:09:38,070 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=741, Invalid=741, Unknown=0, NotChecked=0, Total=1482 [2018-11-23 12:09:38,070 INFO L87 Difference]: Start difference. First operand 62 states and 64 transitions. Second operand 39 states. [2018-11-23 12:09:39,053 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:39,054 INFO L93 Difference]: Finished difference Result 98 states and 107 transitions. [2018-11-23 12:09:39,054 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 38 states. [2018-11-23 12:09:39,054 INFO L78 Accepts]: Start accepts. Automaton has 39 states. Word has length 58 [2018-11-23 12:09:39,054 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:39,054 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 39 states. [2018-11-23 12:09:39,056 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 38 states to 38 states and 96 transitions. [2018-11-23 12:09:39,056 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 39 states. [2018-11-23 12:09:39,057 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 38 states to 38 states and 96 transitions. [2018-11-23 12:09:39,058 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 38 states and 96 transitions. [2018-11-23 12:09:39,290 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:39,291 INFO L225 Difference]: With dead ends: 98 [2018-11-23 12:09:39,291 INFO L226 Difference]: Without dead ends: 78 [2018-11-23 12:09:39,292 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 95 GetRequests, 58 SyntacticMatches, 0 SemanticMatches, 37 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 68 ImplicationChecksByTransitivity, 0.6s TimeCoverageRelationStatistics Valid=741, Invalid=741, Unknown=0, NotChecked=0, Total=1482 [2018-11-23 12:09:39,292 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 78 states. [2018-11-23 12:09:39,340 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 78 to 63. [2018-11-23 12:09:39,341 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:39,341 INFO L82 GeneralOperation]: Start isEquivalent. First operand 78 states. Second operand 63 states. [2018-11-23 12:09:39,341 INFO L74 IsIncluded]: Start isIncluded. First operand 78 states. Second operand 63 states. [2018-11-23 12:09:39,341 INFO L87 Difference]: Start difference. First operand 78 states. Second operand 63 states. [2018-11-23 12:09:39,342 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:39,343 INFO L93 Difference]: Finished difference Result 78 states and 85 transitions. [2018-11-23 12:09:39,343 INFO L276 IsEmpty]: Start isEmpty. Operand 78 states and 85 transitions. [2018-11-23 12:09:39,343 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:39,343 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:39,343 INFO L74 IsIncluded]: Start isIncluded. First operand 63 states. Second operand 78 states. [2018-11-23 12:09:39,343 INFO L87 Difference]: Start difference. First operand 63 states. Second operand 78 states. [2018-11-23 12:09:39,344 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:39,345 INFO L93 Difference]: Finished difference Result 78 states and 85 transitions. [2018-11-23 12:09:39,345 INFO L276 IsEmpty]: Start isEmpty. Operand 78 states and 85 transitions. [2018-11-23 12:09:39,345 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:39,345 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:39,345 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:39,345 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:39,346 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 63 states. [2018-11-23 12:09:39,346 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 63 states to 63 states and 65 transitions. [2018-11-23 12:09:39,347 INFO L78 Accepts]: Start accepts. Automaton has 63 states and 65 transitions. Word has length 58 [2018-11-23 12:09:39,347 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:39,347 INFO L480 AbstractCegarLoop]: Abstraction has 63 states and 65 transitions. [2018-11-23 12:09:39,347 INFO L481 AbstractCegarLoop]: Interpolant automaton has 39 states. [2018-11-23 12:09:39,347 INFO L276 IsEmpty]: Start isEmpty. Operand 63 states and 65 transitions. [2018-11-23 12:09:39,347 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 60 [2018-11-23 12:09:39,348 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:39,348 INFO L402 BasicCegarLoop]: trace histogram [36, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:39,348 INFO L423 AbstractCegarLoop]: === Iteration 24 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:39,348 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:39,348 INFO L82 PathProgramCache]: Analyzing trace with hash 159047206, now seen corresponding path program 21 times [2018-11-23 12:09:39,349 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:39,349 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:39,349 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:39,349 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:39,350 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:39,381 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:40,152 INFO L256 TraceCheckUtils]: 0: Hoare triple {8646#true} call ULTIMATE.init(); {8646#true} is VALID [2018-11-23 12:09:40,152 INFO L273 TraceCheckUtils]: 1: Hoare triple {8646#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {8646#true} is VALID [2018-11-23 12:09:40,152 INFO L273 TraceCheckUtils]: 2: Hoare triple {8646#true} assume true; {8646#true} is VALID [2018-11-23 12:09:40,152 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {8646#true} {8646#true} #60#return; {8646#true} is VALID [2018-11-23 12:09:40,153 INFO L256 TraceCheckUtils]: 4: Hoare triple {8646#true} call #t~ret4 := main(); {8646#true} is VALID [2018-11-23 12:09:40,153 INFO L273 TraceCheckUtils]: 5: Hoare triple {8646#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; {8648#(= main_~i~0 0)} is VALID [2018-11-23 12:09:40,154 INFO L273 TraceCheckUtils]: 6: Hoare triple {8648#(= 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; {8649#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:40,155 INFO L273 TraceCheckUtils]: 7: Hoare triple {8649#(<= 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; {8650#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:40,156 INFO L273 TraceCheckUtils]: 8: Hoare triple {8650#(<= 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; {8651#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:40,156 INFO L273 TraceCheckUtils]: 9: Hoare triple {8651#(<= 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; {8652#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:40,157 INFO L273 TraceCheckUtils]: 10: Hoare triple {8652#(<= 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; {8653#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:40,158 INFO L273 TraceCheckUtils]: 11: Hoare triple {8653#(<= 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; {8654#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:40,159 INFO L273 TraceCheckUtils]: 12: Hoare triple {8654#(<= 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; {8655#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:40,160 INFO L273 TraceCheckUtils]: 13: Hoare triple {8655#(<= 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; {8656#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:40,161 INFO L273 TraceCheckUtils]: 14: Hoare triple {8656#(<= 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; {8657#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:40,162 INFO L273 TraceCheckUtils]: 15: Hoare triple {8657#(<= 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; {8658#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:40,163 INFO L273 TraceCheckUtils]: 16: Hoare triple {8658#(<= 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; {8659#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:40,164 INFO L273 TraceCheckUtils]: 17: Hoare triple {8659#(<= 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; {8660#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:40,165 INFO L273 TraceCheckUtils]: 18: Hoare triple {8660#(<= 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; {8661#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:40,166 INFO L273 TraceCheckUtils]: 19: Hoare triple {8661#(<= 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; {8662#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:40,167 INFO L273 TraceCheckUtils]: 20: Hoare triple {8662#(<= 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; {8663#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:40,168 INFO L273 TraceCheckUtils]: 21: Hoare triple {8663#(<= 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; {8664#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:40,169 INFO L273 TraceCheckUtils]: 22: Hoare triple {8664#(<= 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; {8665#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:40,170 INFO L273 TraceCheckUtils]: 23: Hoare triple {8665#(<= 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; {8666#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:40,171 INFO L273 TraceCheckUtils]: 24: Hoare triple {8666#(<= 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; {8667#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:40,172 INFO L273 TraceCheckUtils]: 25: Hoare triple {8667#(<= 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; {8668#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:40,173 INFO L273 TraceCheckUtils]: 26: Hoare triple {8668#(<= 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; {8669#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:40,174 INFO L273 TraceCheckUtils]: 27: Hoare triple {8669#(<= 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; {8670#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:40,175 INFO L273 TraceCheckUtils]: 28: Hoare triple {8670#(<= 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; {8671#(<= main_~i~0 23)} is VALID [2018-11-23 12:09:40,176 INFO L273 TraceCheckUtils]: 29: Hoare triple {8671#(<= 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; {8672#(<= main_~i~0 24)} is VALID [2018-11-23 12:09:40,177 INFO L273 TraceCheckUtils]: 30: Hoare triple {8672#(<= 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; {8673#(<= main_~i~0 25)} is VALID [2018-11-23 12:09:40,178 INFO L273 TraceCheckUtils]: 31: Hoare triple {8673#(<= 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; {8674#(<= main_~i~0 26)} is VALID [2018-11-23 12:09:40,179 INFO L273 TraceCheckUtils]: 32: Hoare triple {8674#(<= 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; {8675#(<= main_~i~0 27)} is VALID [2018-11-23 12:09:40,180 INFO L273 TraceCheckUtils]: 33: Hoare triple {8675#(<= 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; {8676#(<= main_~i~0 28)} is VALID [2018-11-23 12:09:40,181 INFO L273 TraceCheckUtils]: 34: Hoare triple {8676#(<= 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; {8677#(<= main_~i~0 29)} is VALID [2018-11-23 12:09:40,183 INFO L273 TraceCheckUtils]: 35: Hoare triple {8677#(<= 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; {8678#(<= main_~i~0 30)} is VALID [2018-11-23 12:09:40,184 INFO L273 TraceCheckUtils]: 36: Hoare triple {8678#(<= 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; {8679#(<= main_~i~0 31)} is VALID [2018-11-23 12:09:40,185 INFO L273 TraceCheckUtils]: 37: Hoare triple {8679#(<= 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; {8680#(<= main_~i~0 32)} is VALID [2018-11-23 12:09:40,186 INFO L273 TraceCheckUtils]: 38: Hoare triple {8680#(<= 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; {8681#(<= main_~i~0 33)} is VALID [2018-11-23 12:09:40,187 INFO L273 TraceCheckUtils]: 39: Hoare triple {8681#(<= 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; {8682#(<= main_~i~0 34)} is VALID [2018-11-23 12:09:40,188 INFO L273 TraceCheckUtils]: 40: Hoare triple {8682#(<= 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; {8683#(<= main_~i~0 35)} is VALID [2018-11-23 12:09:40,189 INFO L273 TraceCheckUtils]: 41: Hoare triple {8683#(<= 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; {8684#(<= main_~i~0 36)} is VALID [2018-11-23 12:09:40,189 INFO L273 TraceCheckUtils]: 42: Hoare triple {8684#(<= main_~i~0 36)} assume !(~i~0 < 100000); {8647#false} is VALID [2018-11-23 12:09:40,190 INFO L273 TraceCheckUtils]: 43: Hoare triple {8647#false} ~i~0 := 1; {8647#false} is VALID [2018-11-23 12:09:40,190 INFO L273 TraceCheckUtils]: 44: Hoare triple {8647#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8647#false} is VALID [2018-11-23 12:09:40,190 INFO L273 TraceCheckUtils]: 45: Hoare triple {8647#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8647#false} is VALID [2018-11-23 12:09:40,190 INFO L273 TraceCheckUtils]: 46: Hoare triple {8647#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8647#false} is VALID [2018-11-23 12:09:40,191 INFO L273 TraceCheckUtils]: 47: Hoare triple {8647#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8647#false} is VALID [2018-11-23 12:09:40,191 INFO L273 TraceCheckUtils]: 48: Hoare triple {8647#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8647#false} is VALID [2018-11-23 12:09:40,191 INFO L273 TraceCheckUtils]: 49: Hoare triple {8647#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8647#false} is VALID [2018-11-23 12:09:40,191 INFO L273 TraceCheckUtils]: 50: Hoare triple {8647#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8647#false} is VALID [2018-11-23 12:09:40,191 INFO L273 TraceCheckUtils]: 51: Hoare triple {8647#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8647#false} is VALID [2018-11-23 12:09:40,192 INFO L273 TraceCheckUtils]: 52: Hoare triple {8647#false} assume !(~i~0 < 100000); {8647#false} is VALID [2018-11-23 12:09:40,192 INFO L273 TraceCheckUtils]: 53: Hoare triple {8647#false} ~i~0 := 1;~j~0 := 0; {8647#false} is VALID [2018-11-23 12:09:40,192 INFO L273 TraceCheckUtils]: 54: Hoare triple {8647#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 + 7 * ~j~0), 4); {8647#false} is VALID [2018-11-23 12:09:40,192 INFO L256 TraceCheckUtils]: 55: Hoare triple {8647#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {8647#false} is VALID [2018-11-23 12:09:40,192 INFO L273 TraceCheckUtils]: 56: Hoare triple {8647#false} ~cond := #in~cond; {8647#false} is VALID [2018-11-23 12:09:40,193 INFO L273 TraceCheckUtils]: 57: Hoare triple {8647#false} assume 0 == ~cond; {8647#false} is VALID [2018-11-23 12:09:40,193 INFO L273 TraceCheckUtils]: 58: Hoare triple {8647#false} assume !false; {8647#false} is VALID [2018-11-23 12:09:40,196 INFO L134 CoverageAnalysis]: Checked inductivity of 702 backedges. 0 proven. 666 refuted. 0 times theorem prover too weak. 36 trivial. 0 not checked. [2018-11-23 12:09:40,196 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:40,196 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:09:40,205 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:09:40,402 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 5 check-sat command(s) [2018-11-23 12:09:40,402 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:40,417 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:40,418 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:40,609 INFO L256 TraceCheckUtils]: 0: Hoare triple {8646#true} call ULTIMATE.init(); {8646#true} is VALID [2018-11-23 12:09:40,609 INFO L273 TraceCheckUtils]: 1: Hoare triple {8646#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {8646#true} is VALID [2018-11-23 12:09:40,609 INFO L273 TraceCheckUtils]: 2: Hoare triple {8646#true} assume true; {8646#true} is VALID [2018-11-23 12:09:40,610 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {8646#true} {8646#true} #60#return; {8646#true} is VALID [2018-11-23 12:09:40,610 INFO L256 TraceCheckUtils]: 4: Hoare triple {8646#true} call #t~ret4 := main(); {8646#true} is VALID [2018-11-23 12:09:40,610 INFO L273 TraceCheckUtils]: 5: Hoare triple {8646#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; {8646#true} is VALID [2018-11-23 12:09:40,610 INFO L273 TraceCheckUtils]: 6: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,611 INFO L273 TraceCheckUtils]: 7: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,611 INFO L273 TraceCheckUtils]: 8: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,611 INFO L273 TraceCheckUtils]: 9: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,611 INFO L273 TraceCheckUtils]: 10: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,611 INFO L273 TraceCheckUtils]: 11: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,612 INFO L273 TraceCheckUtils]: 12: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,612 INFO L273 TraceCheckUtils]: 13: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,612 INFO L273 TraceCheckUtils]: 14: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,612 INFO L273 TraceCheckUtils]: 15: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,612 INFO L273 TraceCheckUtils]: 16: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,612 INFO L273 TraceCheckUtils]: 17: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,612 INFO L273 TraceCheckUtils]: 18: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,613 INFO L273 TraceCheckUtils]: 19: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,613 INFO L273 TraceCheckUtils]: 20: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,613 INFO L273 TraceCheckUtils]: 21: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,613 INFO L273 TraceCheckUtils]: 22: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,613 INFO L273 TraceCheckUtils]: 23: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,613 INFO L273 TraceCheckUtils]: 24: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,613 INFO L273 TraceCheckUtils]: 25: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,613 INFO L273 TraceCheckUtils]: 26: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,613 INFO L273 TraceCheckUtils]: 27: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,614 INFO L273 TraceCheckUtils]: 28: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,614 INFO L273 TraceCheckUtils]: 29: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,614 INFO L273 TraceCheckUtils]: 30: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,614 INFO L273 TraceCheckUtils]: 31: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,614 INFO L273 TraceCheckUtils]: 32: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,614 INFO L273 TraceCheckUtils]: 33: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,614 INFO L273 TraceCheckUtils]: 34: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,614 INFO L273 TraceCheckUtils]: 35: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,614 INFO L273 TraceCheckUtils]: 36: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,615 INFO L273 TraceCheckUtils]: 37: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,615 INFO L273 TraceCheckUtils]: 38: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,615 INFO L273 TraceCheckUtils]: 39: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,615 INFO L273 TraceCheckUtils]: 40: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,615 INFO L273 TraceCheckUtils]: 41: Hoare triple {8646#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {8646#true} is VALID [2018-11-23 12:09:40,615 INFO L273 TraceCheckUtils]: 42: Hoare triple {8646#true} assume !(~i~0 < 100000); {8646#true} is VALID [2018-11-23 12:09:40,616 INFO L273 TraceCheckUtils]: 43: Hoare triple {8646#true} ~i~0 := 1; {8649#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:40,616 INFO L273 TraceCheckUtils]: 44: Hoare triple {8649#(<= 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8656#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:40,617 INFO L273 TraceCheckUtils]: 45: Hoare triple {8656#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8663#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:40,618 INFO L273 TraceCheckUtils]: 46: Hoare triple {8663#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8670#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:40,618 INFO L273 TraceCheckUtils]: 47: Hoare triple {8670#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8677#(<= main_~i~0 29)} is VALID [2018-11-23 12:09:40,619 INFO L273 TraceCheckUtils]: 48: Hoare triple {8677#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8684#(<= main_~i~0 36)} is VALID [2018-11-23 12:09:40,620 INFO L273 TraceCheckUtils]: 49: Hoare triple {8684#(<= main_~i~0 36)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8835#(<= main_~i~0 43)} is VALID [2018-11-23 12:09:40,621 INFO L273 TraceCheckUtils]: 50: Hoare triple {8835#(<= main_~i~0 43)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8839#(<= main_~i~0 50)} is VALID [2018-11-23 12:09:40,622 INFO L273 TraceCheckUtils]: 51: Hoare triple {8839#(<= main_~i~0 50)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {8843#(<= main_~i~0 57)} is VALID [2018-11-23 12:09:40,623 INFO L273 TraceCheckUtils]: 52: Hoare triple {8843#(<= main_~i~0 57)} assume !(~i~0 < 100000); {8647#false} is VALID [2018-11-23 12:09:40,623 INFO L273 TraceCheckUtils]: 53: Hoare triple {8647#false} ~i~0 := 1;~j~0 := 0; {8647#false} is VALID [2018-11-23 12:09:40,623 INFO L273 TraceCheckUtils]: 54: Hoare triple {8647#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 + 7 * ~j~0), 4); {8647#false} is VALID [2018-11-23 12:09:40,623 INFO L256 TraceCheckUtils]: 55: Hoare triple {8647#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {8647#false} is VALID [2018-11-23 12:09:40,624 INFO L273 TraceCheckUtils]: 56: Hoare triple {8647#false} ~cond := #in~cond; {8647#false} is VALID [2018-11-23 12:09:40,624 INFO L273 TraceCheckUtils]: 57: Hoare triple {8647#false} assume 0 == ~cond; {8647#false} is VALID [2018-11-23 12:09:40,624 INFO L273 TraceCheckUtils]: 58: Hoare triple {8647#false} assume !false; {8647#false} is VALID [2018-11-23 12:09:40,627 INFO L134 CoverageAnalysis]: Checked inductivity of 702 backedges. 0 proven. 36 refuted. 0 times theorem prover too weak. 666 trivial. 0 not checked. [2018-11-23 12:09:40,646 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:40,647 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [39, 11] total 42 [2018-11-23 12:09:40,647 INFO L78 Accepts]: Start accepts. Automaton has 42 states. Word has length 59 [2018-11-23 12:09:40,647 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:40,648 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 42 states. [2018-11-23 12:09:41,100 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 65 edges. 65 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:41,100 INFO L459 AbstractCegarLoop]: Interpolant automaton has 42 states [2018-11-23 12:09:41,101 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 42 interpolants. [2018-11-23 12:09:41,102 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=861, Invalid=861, Unknown=0, NotChecked=0, Total=1722 [2018-11-23 12:09:41,102 INFO L87 Difference]: Start difference. First operand 63 states and 65 transitions. Second operand 42 states. [2018-11-23 12:09:42,333 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:42,334 INFO L93 Difference]: Finished difference Result 115 states and 132 transitions. [2018-11-23 12:09:42,334 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 42 states. [2018-11-23 12:09:42,334 INFO L78 Accepts]: Start accepts. Automaton has 42 states. Word has length 59 [2018-11-23 12:09:42,334 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:42,334 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 42 states. [2018-11-23 12:09:42,336 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 42 states to 42 states and 124 transitions. [2018-11-23 12:09:42,336 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 42 states. [2018-11-23 12:09:42,338 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 42 states to 42 states and 124 transitions. [2018-11-23 12:09:42,338 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 42 states and 124 transitions. [2018-11-23 12:09:42,518 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 124 edges. 124 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:42,520 INFO L225 Difference]: With dead ends: 115 [2018-11-23 12:09:42,520 INFO L226 Difference]: Without dead ends: 95 [2018-11-23 12:09:42,521 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 97 GetRequests, 57 SyntacticMatches, 0 SemanticMatches, 40 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.7s TimeCoverageRelationStatistics Valid=861, Invalid=861, Unknown=0, NotChecked=0, Total=1722 [2018-11-23 12:09:42,521 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 95 states. [2018-11-23 12:09:42,567 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 95 to 68. [2018-11-23 12:09:42,568 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:42,568 INFO L82 GeneralOperation]: Start isEquivalent. First operand 95 states. Second operand 68 states. [2018-11-23 12:09:42,568 INFO L74 IsIncluded]: Start isIncluded. First operand 95 states. Second operand 68 states. [2018-11-23 12:09:42,568 INFO L87 Difference]: Start difference. First operand 95 states. Second operand 68 states. [2018-11-23 12:09:42,570 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:42,571 INFO L93 Difference]: Finished difference Result 95 states and 106 transitions. [2018-11-23 12:09:42,571 INFO L276 IsEmpty]: Start isEmpty. Operand 95 states and 106 transitions. [2018-11-23 12:09:42,571 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:42,571 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:42,572 INFO L74 IsIncluded]: Start isIncluded. First operand 68 states. Second operand 95 states. [2018-11-23 12:09:42,572 INFO L87 Difference]: Start difference. First operand 68 states. Second operand 95 states. [2018-11-23 12:09:42,574 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:42,574 INFO L93 Difference]: Finished difference Result 95 states and 106 transitions. [2018-11-23 12:09:42,574 INFO L276 IsEmpty]: Start isEmpty. Operand 95 states and 106 transitions. [2018-11-23 12:09:42,575 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:42,575 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:42,575 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:42,575 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:42,575 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 68 states. [2018-11-23 12:09:42,576 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 68 states to 68 states and 70 transitions. [2018-11-23 12:09:42,576 INFO L78 Accepts]: Start accepts. Automaton has 68 states and 70 transitions. Word has length 59 [2018-11-23 12:09:42,577 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:42,577 INFO L480 AbstractCegarLoop]: Abstraction has 68 states and 70 transitions. [2018-11-23 12:09:42,577 INFO L481 AbstractCegarLoop]: Interpolant automaton has 42 states. [2018-11-23 12:09:42,577 INFO L276 IsEmpty]: Start isEmpty. Operand 68 states and 70 transitions. [2018-11-23 12:09:42,577 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 65 [2018-11-23 12:09:42,578 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:42,578 INFO L402 BasicCegarLoop]: trace histogram [40, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:42,578 INFO L423 AbstractCegarLoop]: === Iteration 25 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:42,578 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:42,578 INFO L82 PathProgramCache]: Analyzing trace with hash -1524785175, now seen corresponding path program 22 times [2018-11-23 12:09:42,579 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:42,579 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:42,579 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:42,580 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:42,580 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:42,620 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:43,604 INFO L256 TraceCheckUtils]: 0: Hoare triple {9383#true} call ULTIMATE.init(); {9383#true} is VALID [2018-11-23 12:09:43,604 INFO L273 TraceCheckUtils]: 1: Hoare triple {9383#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {9383#true} is VALID [2018-11-23 12:09:43,604 INFO L273 TraceCheckUtils]: 2: Hoare triple {9383#true} assume true; {9383#true} is VALID [2018-11-23 12:09:43,605 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {9383#true} {9383#true} #60#return; {9383#true} is VALID [2018-11-23 12:09:43,605 INFO L256 TraceCheckUtils]: 4: Hoare triple {9383#true} call #t~ret4 := main(); {9383#true} is VALID [2018-11-23 12:09:43,605 INFO L273 TraceCheckUtils]: 5: Hoare triple {9383#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; {9385#(= main_~i~0 0)} is VALID [2018-11-23 12:09:43,606 INFO L273 TraceCheckUtils]: 6: Hoare triple {9385#(= 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; {9386#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:43,608 INFO L273 TraceCheckUtils]: 7: Hoare triple {9386#(<= 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; {9387#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:43,609 INFO L273 TraceCheckUtils]: 8: Hoare triple {9387#(<= 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; {9388#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:43,610 INFO L273 TraceCheckUtils]: 9: Hoare triple {9388#(<= 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; {9389#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:43,611 INFO L273 TraceCheckUtils]: 10: Hoare triple {9389#(<= 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; {9390#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:43,612 INFO L273 TraceCheckUtils]: 11: Hoare triple {9390#(<= 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; {9391#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:43,613 INFO L273 TraceCheckUtils]: 12: Hoare triple {9391#(<= 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; {9392#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:43,614 INFO L273 TraceCheckUtils]: 13: Hoare triple {9392#(<= 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; {9393#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:43,615 INFO L273 TraceCheckUtils]: 14: Hoare triple {9393#(<= 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; {9394#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:43,616 INFO L273 TraceCheckUtils]: 15: Hoare triple {9394#(<= 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; {9395#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:43,617 INFO L273 TraceCheckUtils]: 16: Hoare triple {9395#(<= 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; {9396#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:43,618 INFO L273 TraceCheckUtils]: 17: Hoare triple {9396#(<= 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; {9397#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:43,619 INFO L273 TraceCheckUtils]: 18: Hoare triple {9397#(<= 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; {9398#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:43,620 INFO L273 TraceCheckUtils]: 19: Hoare triple {9398#(<= 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; {9399#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:43,621 INFO L273 TraceCheckUtils]: 20: Hoare triple {9399#(<= 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; {9400#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:43,622 INFO L273 TraceCheckUtils]: 21: Hoare triple {9400#(<= 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; {9401#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:43,623 INFO L273 TraceCheckUtils]: 22: Hoare triple {9401#(<= 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; {9402#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:43,624 INFO L273 TraceCheckUtils]: 23: Hoare triple {9402#(<= 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; {9403#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:43,625 INFO L273 TraceCheckUtils]: 24: Hoare triple {9403#(<= 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; {9404#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:43,626 INFO L273 TraceCheckUtils]: 25: Hoare triple {9404#(<= 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; {9405#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:43,627 INFO L273 TraceCheckUtils]: 26: Hoare triple {9405#(<= 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; {9406#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:43,628 INFO L273 TraceCheckUtils]: 27: Hoare triple {9406#(<= 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; {9407#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:43,629 INFO L273 TraceCheckUtils]: 28: Hoare triple {9407#(<= 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; {9408#(<= main_~i~0 23)} is VALID [2018-11-23 12:09:43,630 INFO L273 TraceCheckUtils]: 29: Hoare triple {9408#(<= 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; {9409#(<= main_~i~0 24)} is VALID [2018-11-23 12:09:43,631 INFO L273 TraceCheckUtils]: 30: Hoare triple {9409#(<= 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; {9410#(<= main_~i~0 25)} is VALID [2018-11-23 12:09:43,632 INFO L273 TraceCheckUtils]: 31: Hoare triple {9410#(<= 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; {9411#(<= main_~i~0 26)} is VALID [2018-11-23 12:09:43,633 INFO L273 TraceCheckUtils]: 32: Hoare triple {9411#(<= 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; {9412#(<= main_~i~0 27)} is VALID [2018-11-23 12:09:43,634 INFO L273 TraceCheckUtils]: 33: Hoare triple {9412#(<= 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; {9413#(<= main_~i~0 28)} is VALID [2018-11-23 12:09:43,635 INFO L273 TraceCheckUtils]: 34: Hoare triple {9413#(<= 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; {9414#(<= main_~i~0 29)} is VALID [2018-11-23 12:09:43,636 INFO L273 TraceCheckUtils]: 35: Hoare triple {9414#(<= 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; {9415#(<= main_~i~0 30)} is VALID [2018-11-23 12:09:43,637 INFO L273 TraceCheckUtils]: 36: Hoare triple {9415#(<= 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; {9416#(<= main_~i~0 31)} is VALID [2018-11-23 12:09:43,638 INFO L273 TraceCheckUtils]: 37: Hoare triple {9416#(<= 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; {9417#(<= main_~i~0 32)} is VALID [2018-11-23 12:09:43,639 INFO L273 TraceCheckUtils]: 38: Hoare triple {9417#(<= 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; {9418#(<= main_~i~0 33)} is VALID [2018-11-23 12:09:43,640 INFO L273 TraceCheckUtils]: 39: Hoare triple {9418#(<= 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; {9419#(<= main_~i~0 34)} is VALID [2018-11-23 12:09:43,641 INFO L273 TraceCheckUtils]: 40: Hoare triple {9419#(<= 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; {9420#(<= main_~i~0 35)} is VALID [2018-11-23 12:09:43,642 INFO L273 TraceCheckUtils]: 41: Hoare triple {9420#(<= 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; {9421#(<= main_~i~0 36)} is VALID [2018-11-23 12:09:43,643 INFO L273 TraceCheckUtils]: 42: Hoare triple {9421#(<= 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; {9422#(<= main_~i~0 37)} is VALID [2018-11-23 12:09:43,644 INFO L273 TraceCheckUtils]: 43: Hoare triple {9422#(<= 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; {9423#(<= main_~i~0 38)} is VALID [2018-11-23 12:09:43,645 INFO L273 TraceCheckUtils]: 44: Hoare triple {9423#(<= 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; {9424#(<= main_~i~0 39)} is VALID [2018-11-23 12:09:43,646 INFO L273 TraceCheckUtils]: 45: Hoare triple {9424#(<= 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; {9425#(<= main_~i~0 40)} is VALID [2018-11-23 12:09:43,647 INFO L273 TraceCheckUtils]: 46: Hoare triple {9425#(<= main_~i~0 40)} assume !(~i~0 < 100000); {9384#false} is VALID [2018-11-23 12:09:43,647 INFO L273 TraceCheckUtils]: 47: Hoare triple {9384#false} ~i~0 := 1; {9384#false} is VALID [2018-11-23 12:09:43,647 INFO L273 TraceCheckUtils]: 48: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:43,647 INFO L273 TraceCheckUtils]: 49: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:43,647 INFO L273 TraceCheckUtils]: 50: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:43,648 INFO L273 TraceCheckUtils]: 51: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:43,648 INFO L273 TraceCheckUtils]: 52: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:43,648 INFO L273 TraceCheckUtils]: 53: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:43,648 INFO L273 TraceCheckUtils]: 54: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:43,648 INFO L273 TraceCheckUtils]: 55: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:43,649 INFO L273 TraceCheckUtils]: 56: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:43,649 INFO L273 TraceCheckUtils]: 57: Hoare triple {9384#false} assume !(~i~0 < 100000); {9384#false} is VALID [2018-11-23 12:09:43,649 INFO L273 TraceCheckUtils]: 58: Hoare triple {9384#false} ~i~0 := 1;~j~0 := 0; {9384#false} is VALID [2018-11-23 12:09:43,649 INFO L273 TraceCheckUtils]: 59: Hoare triple {9384#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 + 7 * ~j~0), 4); {9384#false} is VALID [2018-11-23 12:09:43,649 INFO L256 TraceCheckUtils]: 60: Hoare triple {9384#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {9384#false} is VALID [2018-11-23 12:09:43,650 INFO L273 TraceCheckUtils]: 61: Hoare triple {9384#false} ~cond := #in~cond; {9384#false} is VALID [2018-11-23 12:09:43,650 INFO L273 TraceCheckUtils]: 62: Hoare triple {9384#false} assume 0 == ~cond; {9384#false} is VALID [2018-11-23 12:09:43,650 INFO L273 TraceCheckUtils]: 63: Hoare triple {9384#false} assume !false; {9384#false} is VALID [2018-11-23 12:09:43,653 INFO L134 CoverageAnalysis]: Checked inductivity of 865 backedges. 0 proven. 820 refuted. 0 times theorem prover too weak. 45 trivial. 0 not checked. [2018-11-23 12:09:43,653 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:43,653 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:09:43,664 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:09:43,723 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:09:43,723 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:43,745 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:43,747 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:44,020 INFO L256 TraceCheckUtils]: 0: Hoare triple {9383#true} call ULTIMATE.init(); {9383#true} is VALID [2018-11-23 12:09:44,020 INFO L273 TraceCheckUtils]: 1: Hoare triple {9383#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {9383#true} is VALID [2018-11-23 12:09:44,020 INFO L273 TraceCheckUtils]: 2: Hoare triple {9383#true} assume true; {9383#true} is VALID [2018-11-23 12:09:44,021 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {9383#true} {9383#true} #60#return; {9383#true} is VALID [2018-11-23 12:09:44,021 INFO L256 TraceCheckUtils]: 4: Hoare triple {9383#true} call #t~ret4 := main(); {9383#true} is VALID [2018-11-23 12:09:44,022 INFO L273 TraceCheckUtils]: 5: Hoare triple {9383#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; {9444#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:44,023 INFO L273 TraceCheckUtils]: 6: Hoare triple {9444#(<= 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; {9386#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:44,024 INFO L273 TraceCheckUtils]: 7: Hoare triple {9386#(<= 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; {9387#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:44,024 INFO L273 TraceCheckUtils]: 8: Hoare triple {9387#(<= 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; {9388#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:44,025 INFO L273 TraceCheckUtils]: 9: Hoare triple {9388#(<= 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; {9389#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:44,026 INFO L273 TraceCheckUtils]: 10: Hoare triple {9389#(<= 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; {9390#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:44,027 INFO L273 TraceCheckUtils]: 11: Hoare triple {9390#(<= 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; {9391#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:44,028 INFO L273 TraceCheckUtils]: 12: Hoare triple {9391#(<= 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; {9392#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:44,029 INFO L273 TraceCheckUtils]: 13: Hoare triple {9392#(<= 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; {9393#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:44,030 INFO L273 TraceCheckUtils]: 14: Hoare triple {9393#(<= 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; {9394#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:44,031 INFO L273 TraceCheckUtils]: 15: Hoare triple {9394#(<= 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; {9395#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:44,032 INFO L273 TraceCheckUtils]: 16: Hoare triple {9395#(<= 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; {9396#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:44,033 INFO L273 TraceCheckUtils]: 17: Hoare triple {9396#(<= 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; {9397#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:44,034 INFO L273 TraceCheckUtils]: 18: Hoare triple {9397#(<= 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; {9398#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:44,035 INFO L273 TraceCheckUtils]: 19: Hoare triple {9398#(<= 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; {9399#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:44,036 INFO L273 TraceCheckUtils]: 20: Hoare triple {9399#(<= 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; {9400#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:44,037 INFO L273 TraceCheckUtils]: 21: Hoare triple {9400#(<= 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; {9401#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:44,038 INFO L273 TraceCheckUtils]: 22: Hoare triple {9401#(<= 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; {9402#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:44,039 INFO L273 TraceCheckUtils]: 23: Hoare triple {9402#(<= 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; {9403#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:44,040 INFO L273 TraceCheckUtils]: 24: Hoare triple {9403#(<= 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; {9404#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:44,041 INFO L273 TraceCheckUtils]: 25: Hoare triple {9404#(<= 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; {9405#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:44,042 INFO L273 TraceCheckUtils]: 26: Hoare triple {9405#(<= 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; {9406#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:44,043 INFO L273 TraceCheckUtils]: 27: Hoare triple {9406#(<= 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; {9407#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:44,044 INFO L273 TraceCheckUtils]: 28: Hoare triple {9407#(<= 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; {9408#(<= main_~i~0 23)} is VALID [2018-11-23 12:09:44,045 INFO L273 TraceCheckUtils]: 29: Hoare triple {9408#(<= 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; {9409#(<= main_~i~0 24)} is VALID [2018-11-23 12:09:44,058 INFO L273 TraceCheckUtils]: 30: Hoare triple {9409#(<= 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; {9410#(<= main_~i~0 25)} is VALID [2018-11-23 12:09:44,059 INFO L273 TraceCheckUtils]: 31: Hoare triple {9410#(<= 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; {9411#(<= main_~i~0 26)} is VALID [2018-11-23 12:09:44,060 INFO L273 TraceCheckUtils]: 32: Hoare triple {9411#(<= 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; {9412#(<= main_~i~0 27)} is VALID [2018-11-23 12:09:44,061 INFO L273 TraceCheckUtils]: 33: Hoare triple {9412#(<= 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; {9413#(<= main_~i~0 28)} is VALID [2018-11-23 12:09:44,061 INFO L273 TraceCheckUtils]: 34: Hoare triple {9413#(<= 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; {9414#(<= main_~i~0 29)} is VALID [2018-11-23 12:09:44,062 INFO L273 TraceCheckUtils]: 35: Hoare triple {9414#(<= 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; {9415#(<= main_~i~0 30)} is VALID [2018-11-23 12:09:44,063 INFO L273 TraceCheckUtils]: 36: Hoare triple {9415#(<= 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; {9416#(<= main_~i~0 31)} is VALID [2018-11-23 12:09:44,064 INFO L273 TraceCheckUtils]: 37: Hoare triple {9416#(<= 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; {9417#(<= main_~i~0 32)} is VALID [2018-11-23 12:09:44,065 INFO L273 TraceCheckUtils]: 38: Hoare triple {9417#(<= 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; {9418#(<= main_~i~0 33)} is VALID [2018-11-23 12:09:44,066 INFO L273 TraceCheckUtils]: 39: Hoare triple {9418#(<= 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; {9419#(<= main_~i~0 34)} is VALID [2018-11-23 12:09:44,067 INFO L273 TraceCheckUtils]: 40: Hoare triple {9419#(<= 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; {9420#(<= main_~i~0 35)} is VALID [2018-11-23 12:09:44,068 INFO L273 TraceCheckUtils]: 41: Hoare triple {9420#(<= 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; {9421#(<= main_~i~0 36)} is VALID [2018-11-23 12:09:44,069 INFO L273 TraceCheckUtils]: 42: Hoare triple {9421#(<= 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; {9422#(<= main_~i~0 37)} is VALID [2018-11-23 12:09:44,070 INFO L273 TraceCheckUtils]: 43: Hoare triple {9422#(<= 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; {9423#(<= main_~i~0 38)} is VALID [2018-11-23 12:09:44,071 INFO L273 TraceCheckUtils]: 44: Hoare triple {9423#(<= 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; {9424#(<= main_~i~0 39)} is VALID [2018-11-23 12:09:44,072 INFO L273 TraceCheckUtils]: 45: Hoare triple {9424#(<= 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; {9425#(<= main_~i~0 40)} is VALID [2018-11-23 12:09:44,073 INFO L273 TraceCheckUtils]: 46: Hoare triple {9425#(<= main_~i~0 40)} assume !(~i~0 < 100000); {9384#false} is VALID [2018-11-23 12:09:44,073 INFO L273 TraceCheckUtils]: 47: Hoare triple {9384#false} ~i~0 := 1; {9384#false} is VALID [2018-11-23 12:09:44,074 INFO L273 TraceCheckUtils]: 48: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:44,074 INFO L273 TraceCheckUtils]: 49: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:44,074 INFO L273 TraceCheckUtils]: 50: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:44,074 INFO L273 TraceCheckUtils]: 51: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:44,074 INFO L273 TraceCheckUtils]: 52: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:44,075 INFO L273 TraceCheckUtils]: 53: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:44,075 INFO L273 TraceCheckUtils]: 54: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:44,075 INFO L273 TraceCheckUtils]: 55: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:44,075 INFO L273 TraceCheckUtils]: 56: Hoare triple {9384#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {9384#false} is VALID [2018-11-23 12:09:44,075 INFO L273 TraceCheckUtils]: 57: Hoare triple {9384#false} assume !(~i~0 < 100000); {9384#false} is VALID [2018-11-23 12:09:44,076 INFO L273 TraceCheckUtils]: 58: Hoare triple {9384#false} ~i~0 := 1;~j~0 := 0; {9384#false} is VALID [2018-11-23 12:09:44,076 INFO L273 TraceCheckUtils]: 59: Hoare triple {9384#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 + 7 * ~j~0), 4); {9384#false} is VALID [2018-11-23 12:09:44,076 INFO L256 TraceCheckUtils]: 60: Hoare triple {9384#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {9384#false} is VALID [2018-11-23 12:09:44,076 INFO L273 TraceCheckUtils]: 61: Hoare triple {9384#false} ~cond := #in~cond; {9384#false} is VALID [2018-11-23 12:09:44,076 INFO L273 TraceCheckUtils]: 62: Hoare triple {9384#false} assume 0 == ~cond; {9384#false} is VALID [2018-11-23 12:09:44,077 INFO L273 TraceCheckUtils]: 63: Hoare triple {9384#false} assume !false; {9384#false} is VALID [2018-11-23 12:09:44,079 INFO L134 CoverageAnalysis]: Checked inductivity of 865 backedges. 0 proven. 820 refuted. 0 times theorem prover too weak. 45 trivial. 0 not checked. [2018-11-23 12:09:44,098 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:44,098 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [43, 43] total 44 [2018-11-23 12:09:44,099 INFO L78 Accepts]: Start accepts. Automaton has 44 states. Word has length 64 [2018-11-23 12:09:44,099 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:44,099 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 44 states. [2018-11-23 12:09:44,143 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:09:44,143 INFO L459 AbstractCegarLoop]: Interpolant automaton has 44 states [2018-11-23 12:09:44,144 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 44 interpolants. [2018-11-23 12:09:44,144 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=946, Invalid=946, Unknown=0, NotChecked=0, Total=1892 [2018-11-23 12:09:44,145 INFO L87 Difference]: Start difference. First operand 68 states and 70 transitions. Second operand 44 states. [2018-11-23 12:09:48,409 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:48,410 INFO L93 Difference]: Finished difference Result 108 states and 118 transitions. [2018-11-23 12:09:48,410 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 43 states. [2018-11-23 12:09:48,410 INFO L78 Accepts]: Start accepts. Automaton has 44 states. Word has length 64 [2018-11-23 12:09:48,410 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:48,410 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 44 states. [2018-11-23 12:09:48,413 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 43 states to 43 states and 106 transitions. [2018-11-23 12:09:48,413 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 44 states. [2018-11-23 12:09:48,414 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 43 states to 43 states and 106 transitions. [2018-11-23 12:09:48,414 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 43 states and 106 transitions. [2018-11-23 12:09:48,514 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 106 edges. 106 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:48,516 INFO L225 Difference]: With dead ends: 108 [2018-11-23 12:09:48,516 INFO L226 Difference]: Without dead ends: 87 [2018-11-23 12:09:48,517 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 106 GetRequests, 64 SyntacticMatches, 0 SemanticMatches, 42 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 78 ImplicationChecksByTransitivity, 0.8s TimeCoverageRelationStatistics Valid=946, Invalid=946, Unknown=0, NotChecked=0, Total=1892 [2018-11-23 12:09:48,518 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 87 states. [2018-11-23 12:09:48,571 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 87 to 69. [2018-11-23 12:09:48,572 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:48,572 INFO L82 GeneralOperation]: Start isEquivalent. First operand 87 states. Second operand 69 states. [2018-11-23 12:09:48,572 INFO L74 IsIncluded]: Start isIncluded. First operand 87 states. Second operand 69 states. [2018-11-23 12:09:48,572 INFO L87 Difference]: Start difference. First operand 87 states. Second operand 69 states. [2018-11-23 12:09:48,575 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:48,575 INFO L93 Difference]: Finished difference Result 87 states and 95 transitions. [2018-11-23 12:09:48,575 INFO L276 IsEmpty]: Start isEmpty. Operand 87 states and 95 transitions. [2018-11-23 12:09:48,575 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:48,575 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:48,576 INFO L74 IsIncluded]: Start isIncluded. First operand 69 states. Second operand 87 states. [2018-11-23 12:09:48,576 INFO L87 Difference]: Start difference. First operand 69 states. Second operand 87 states. [2018-11-23 12:09:48,578 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:48,578 INFO L93 Difference]: Finished difference Result 87 states and 95 transitions. [2018-11-23 12:09:48,578 INFO L276 IsEmpty]: Start isEmpty. Operand 87 states and 95 transitions. [2018-11-23 12:09:48,578 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:48,579 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:48,579 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:48,579 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:48,579 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 69 states. [2018-11-23 12:09:48,580 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 69 states to 69 states and 71 transitions. [2018-11-23 12:09:48,580 INFO L78 Accepts]: Start accepts. Automaton has 69 states and 71 transitions. Word has length 64 [2018-11-23 12:09:48,580 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:48,580 INFO L480 AbstractCegarLoop]: Abstraction has 69 states and 71 transitions. [2018-11-23 12:09:48,580 INFO L481 AbstractCegarLoop]: Interpolant automaton has 44 states. [2018-11-23 12:09:48,581 INFO L276 IsEmpty]: Start isEmpty. Operand 69 states and 71 transitions. [2018-11-23 12:09:48,581 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 66 [2018-11-23 12:09:48,581 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:48,581 INFO L402 BasicCegarLoop]: trace histogram [41, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:48,582 INFO L423 AbstractCegarLoop]: === Iteration 26 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:48,582 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:48,582 INFO L82 PathProgramCache]: Analyzing trace with hash -1437923259, now seen corresponding path program 23 times [2018-11-23 12:09:48,582 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:48,582 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:48,583 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:48,583 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:48,583 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:48,625 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:49,776 INFO L256 TraceCheckUtils]: 0: Hoare triple {10112#true} call ULTIMATE.init(); {10112#true} is VALID [2018-11-23 12:09:49,777 INFO L273 TraceCheckUtils]: 1: Hoare triple {10112#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {10112#true} is VALID [2018-11-23 12:09:49,777 INFO L273 TraceCheckUtils]: 2: Hoare triple {10112#true} assume true; {10112#true} is VALID [2018-11-23 12:09:49,777 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {10112#true} {10112#true} #60#return; {10112#true} is VALID [2018-11-23 12:09:49,777 INFO L256 TraceCheckUtils]: 4: Hoare triple {10112#true} call #t~ret4 := main(); {10112#true} is VALID [2018-11-23 12:09:49,781 INFO L273 TraceCheckUtils]: 5: Hoare triple {10112#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; {10114#(= main_~i~0 0)} is VALID [2018-11-23 12:09:49,782 INFO L273 TraceCheckUtils]: 6: Hoare triple {10114#(= 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; {10115#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:49,782 INFO L273 TraceCheckUtils]: 7: Hoare triple {10115#(<= 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; {10116#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:49,783 INFO L273 TraceCheckUtils]: 8: Hoare triple {10116#(<= 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; {10117#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:49,783 INFO L273 TraceCheckUtils]: 9: Hoare triple {10117#(<= 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; {10118#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:49,784 INFO L273 TraceCheckUtils]: 10: Hoare triple {10118#(<= 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; {10119#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:49,785 INFO L273 TraceCheckUtils]: 11: Hoare triple {10119#(<= 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; {10120#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:49,786 INFO L273 TraceCheckUtils]: 12: Hoare triple {10120#(<= 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; {10121#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:49,787 INFO L273 TraceCheckUtils]: 13: Hoare triple {10121#(<= 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; {10122#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:49,788 INFO L273 TraceCheckUtils]: 14: Hoare triple {10122#(<= 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; {10123#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:49,789 INFO L273 TraceCheckUtils]: 15: Hoare triple {10123#(<= 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; {10124#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:49,790 INFO L273 TraceCheckUtils]: 16: Hoare triple {10124#(<= 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; {10125#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:49,791 INFO L273 TraceCheckUtils]: 17: Hoare triple {10125#(<= 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; {10126#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:49,792 INFO L273 TraceCheckUtils]: 18: Hoare triple {10126#(<= 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; {10127#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:49,793 INFO L273 TraceCheckUtils]: 19: Hoare triple {10127#(<= 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; {10128#(<= main_~i~0 14)} is VALID [2018-11-23 12:09:49,794 INFO L273 TraceCheckUtils]: 20: Hoare triple {10128#(<= 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; {10129#(<= main_~i~0 15)} is VALID [2018-11-23 12:09:49,795 INFO L273 TraceCheckUtils]: 21: Hoare triple {10129#(<= 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; {10130#(<= main_~i~0 16)} is VALID [2018-11-23 12:09:49,796 INFO L273 TraceCheckUtils]: 22: Hoare triple {10130#(<= 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; {10131#(<= main_~i~0 17)} is VALID [2018-11-23 12:09:49,797 INFO L273 TraceCheckUtils]: 23: Hoare triple {10131#(<= 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; {10132#(<= main_~i~0 18)} is VALID [2018-11-23 12:09:49,798 INFO L273 TraceCheckUtils]: 24: Hoare triple {10132#(<= 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; {10133#(<= main_~i~0 19)} is VALID [2018-11-23 12:09:49,799 INFO L273 TraceCheckUtils]: 25: Hoare triple {10133#(<= 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; {10134#(<= main_~i~0 20)} is VALID [2018-11-23 12:09:49,800 INFO L273 TraceCheckUtils]: 26: Hoare triple {10134#(<= 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; {10135#(<= main_~i~0 21)} is VALID [2018-11-23 12:09:49,801 INFO L273 TraceCheckUtils]: 27: Hoare triple {10135#(<= 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; {10136#(<= main_~i~0 22)} is VALID [2018-11-23 12:09:49,802 INFO L273 TraceCheckUtils]: 28: Hoare triple {10136#(<= 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; {10137#(<= main_~i~0 23)} is VALID [2018-11-23 12:09:49,803 INFO L273 TraceCheckUtils]: 29: Hoare triple {10137#(<= 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; {10138#(<= main_~i~0 24)} is VALID [2018-11-23 12:09:49,804 INFO L273 TraceCheckUtils]: 30: Hoare triple {10138#(<= 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; {10139#(<= main_~i~0 25)} is VALID [2018-11-23 12:09:49,805 INFO L273 TraceCheckUtils]: 31: Hoare triple {10139#(<= 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; {10140#(<= main_~i~0 26)} is VALID [2018-11-23 12:09:49,806 INFO L273 TraceCheckUtils]: 32: Hoare triple {10140#(<= 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; {10141#(<= main_~i~0 27)} is VALID [2018-11-23 12:09:49,807 INFO L273 TraceCheckUtils]: 33: Hoare triple {10141#(<= 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; {10142#(<= main_~i~0 28)} is VALID [2018-11-23 12:09:49,808 INFO L273 TraceCheckUtils]: 34: Hoare triple {10142#(<= 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; {10143#(<= main_~i~0 29)} is VALID [2018-11-23 12:09:49,809 INFO L273 TraceCheckUtils]: 35: Hoare triple {10143#(<= 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; {10144#(<= main_~i~0 30)} is VALID [2018-11-23 12:09:49,810 INFO L273 TraceCheckUtils]: 36: Hoare triple {10144#(<= 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; {10145#(<= main_~i~0 31)} is VALID [2018-11-23 12:09:49,811 INFO L273 TraceCheckUtils]: 37: Hoare triple {10145#(<= 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; {10146#(<= main_~i~0 32)} is VALID [2018-11-23 12:09:49,812 INFO L273 TraceCheckUtils]: 38: Hoare triple {10146#(<= 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; {10147#(<= main_~i~0 33)} is VALID [2018-11-23 12:09:49,813 INFO L273 TraceCheckUtils]: 39: Hoare triple {10147#(<= 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; {10148#(<= main_~i~0 34)} is VALID [2018-11-23 12:09:49,814 INFO L273 TraceCheckUtils]: 40: Hoare triple {10148#(<= 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; {10149#(<= main_~i~0 35)} is VALID [2018-11-23 12:09:49,815 INFO L273 TraceCheckUtils]: 41: Hoare triple {10149#(<= 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; {10150#(<= main_~i~0 36)} is VALID [2018-11-23 12:09:49,816 INFO L273 TraceCheckUtils]: 42: Hoare triple {10150#(<= 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; {10151#(<= main_~i~0 37)} is VALID [2018-11-23 12:09:49,817 INFO L273 TraceCheckUtils]: 43: Hoare triple {10151#(<= 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; {10152#(<= main_~i~0 38)} is VALID [2018-11-23 12:09:49,818 INFO L273 TraceCheckUtils]: 44: Hoare triple {10152#(<= 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; {10153#(<= main_~i~0 39)} is VALID [2018-11-23 12:09:49,819 INFO L273 TraceCheckUtils]: 45: Hoare triple {10153#(<= 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; {10154#(<= main_~i~0 40)} is VALID [2018-11-23 12:09:49,820 INFO L273 TraceCheckUtils]: 46: Hoare triple {10154#(<= 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; {10155#(<= main_~i~0 41)} is VALID [2018-11-23 12:09:49,821 INFO L273 TraceCheckUtils]: 47: Hoare triple {10155#(<= main_~i~0 41)} assume !(~i~0 < 100000); {10113#false} is VALID [2018-11-23 12:09:49,821 INFO L273 TraceCheckUtils]: 48: Hoare triple {10113#false} ~i~0 := 1; {10113#false} is VALID [2018-11-23 12:09:49,821 INFO L273 TraceCheckUtils]: 49: Hoare triple {10113#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10113#false} is VALID [2018-11-23 12:09:49,822 INFO L273 TraceCheckUtils]: 50: Hoare triple {10113#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10113#false} is VALID [2018-11-23 12:09:49,822 INFO L273 TraceCheckUtils]: 51: Hoare triple {10113#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10113#false} is VALID [2018-11-23 12:09:49,822 INFO L273 TraceCheckUtils]: 52: Hoare triple {10113#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10113#false} is VALID [2018-11-23 12:09:49,822 INFO L273 TraceCheckUtils]: 53: Hoare triple {10113#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10113#false} is VALID [2018-11-23 12:09:49,822 INFO L273 TraceCheckUtils]: 54: Hoare triple {10113#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10113#false} is VALID [2018-11-23 12:09:49,823 INFO L273 TraceCheckUtils]: 55: Hoare triple {10113#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10113#false} is VALID [2018-11-23 12:09:49,823 INFO L273 TraceCheckUtils]: 56: Hoare triple {10113#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10113#false} is VALID [2018-11-23 12:09:49,823 INFO L273 TraceCheckUtils]: 57: Hoare triple {10113#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10113#false} is VALID [2018-11-23 12:09:49,823 INFO L273 TraceCheckUtils]: 58: Hoare triple {10113#false} assume !(~i~0 < 100000); {10113#false} is VALID [2018-11-23 12:09:49,823 INFO L273 TraceCheckUtils]: 59: Hoare triple {10113#false} ~i~0 := 1;~j~0 := 0; {10113#false} is VALID [2018-11-23 12:09:49,824 INFO L273 TraceCheckUtils]: 60: Hoare triple {10113#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 + 7 * ~j~0), 4); {10113#false} is VALID [2018-11-23 12:09:49,824 INFO L256 TraceCheckUtils]: 61: Hoare triple {10113#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {10113#false} is VALID [2018-11-23 12:09:49,824 INFO L273 TraceCheckUtils]: 62: Hoare triple {10113#false} ~cond := #in~cond; {10113#false} is VALID [2018-11-23 12:09:49,824 INFO L273 TraceCheckUtils]: 63: Hoare triple {10113#false} assume 0 == ~cond; {10113#false} is VALID [2018-11-23 12:09:49,824 INFO L273 TraceCheckUtils]: 64: Hoare triple {10113#false} assume !false; {10113#false} is VALID [2018-11-23 12:09:49,827 INFO L134 CoverageAnalysis]: Checked inductivity of 906 backedges. 0 proven. 861 refuted. 0 times theorem prover too weak. 45 trivial. 0 not checked. [2018-11-23 12:09:49,827 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:49,827 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:09:49,835 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:10:19,977 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 22 check-sat command(s) [2018-11-23 12:10:19,977 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:20,017 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:20,018 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:20,256 INFO L256 TraceCheckUtils]: 0: Hoare triple {10112#true} call ULTIMATE.init(); {10112#true} is VALID [2018-11-23 12:10:20,257 INFO L273 TraceCheckUtils]: 1: Hoare triple {10112#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {10112#true} is VALID [2018-11-23 12:10:20,257 INFO L273 TraceCheckUtils]: 2: Hoare triple {10112#true} assume true; {10112#true} is VALID [2018-11-23 12:10:20,257 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {10112#true} {10112#true} #60#return; {10112#true} is VALID [2018-11-23 12:10:20,257 INFO L256 TraceCheckUtils]: 4: Hoare triple {10112#true} call #t~ret4 := main(); {10112#true} is VALID [2018-11-23 12:10:20,257 INFO L273 TraceCheckUtils]: 5: Hoare triple {10112#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; {10112#true} is VALID [2018-11-23 12:10:20,258 INFO L273 TraceCheckUtils]: 6: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,258 INFO L273 TraceCheckUtils]: 7: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,258 INFO L273 TraceCheckUtils]: 8: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,258 INFO L273 TraceCheckUtils]: 9: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,258 INFO L273 TraceCheckUtils]: 10: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,258 INFO L273 TraceCheckUtils]: 11: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,259 INFO L273 TraceCheckUtils]: 12: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,259 INFO L273 TraceCheckUtils]: 13: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,259 INFO L273 TraceCheckUtils]: 14: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,259 INFO L273 TraceCheckUtils]: 15: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,259 INFO L273 TraceCheckUtils]: 16: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,259 INFO L273 TraceCheckUtils]: 17: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,259 INFO L273 TraceCheckUtils]: 18: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,260 INFO L273 TraceCheckUtils]: 19: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,260 INFO L273 TraceCheckUtils]: 20: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,260 INFO L273 TraceCheckUtils]: 21: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,260 INFO L273 TraceCheckUtils]: 22: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,260 INFO L273 TraceCheckUtils]: 23: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,260 INFO L273 TraceCheckUtils]: 24: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,260 INFO L273 TraceCheckUtils]: 25: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,260 INFO L273 TraceCheckUtils]: 26: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,261 INFO L273 TraceCheckUtils]: 27: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,261 INFO L273 TraceCheckUtils]: 28: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,261 INFO L273 TraceCheckUtils]: 29: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,261 INFO L273 TraceCheckUtils]: 30: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,261 INFO L273 TraceCheckUtils]: 31: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,261 INFO L273 TraceCheckUtils]: 32: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,261 INFO L273 TraceCheckUtils]: 33: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,261 INFO L273 TraceCheckUtils]: 34: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,261 INFO L273 TraceCheckUtils]: 35: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,262 INFO L273 TraceCheckUtils]: 36: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,262 INFO L273 TraceCheckUtils]: 37: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,262 INFO L273 TraceCheckUtils]: 38: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,262 INFO L273 TraceCheckUtils]: 39: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,262 INFO L273 TraceCheckUtils]: 40: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,262 INFO L273 TraceCheckUtils]: 41: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,262 INFO L273 TraceCheckUtils]: 42: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,262 INFO L273 TraceCheckUtils]: 43: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,262 INFO L273 TraceCheckUtils]: 44: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,263 INFO L273 TraceCheckUtils]: 45: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,263 INFO L273 TraceCheckUtils]: 46: Hoare triple {10112#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10112#true} is VALID [2018-11-23 12:10:20,263 INFO L273 TraceCheckUtils]: 47: Hoare triple {10112#true} assume !(~i~0 < 100000); {10112#true} is VALID [2018-11-23 12:10:20,263 INFO L273 TraceCheckUtils]: 48: Hoare triple {10112#true} ~i~0 := 1; {10115#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:20,264 INFO L273 TraceCheckUtils]: 49: Hoare triple {10115#(<= 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10122#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:20,264 INFO L273 TraceCheckUtils]: 50: Hoare triple {10122#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10129#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:20,265 INFO L273 TraceCheckUtils]: 51: Hoare triple {10129#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10136#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:20,266 INFO L273 TraceCheckUtils]: 52: Hoare triple {10136#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10143#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:20,266 INFO L273 TraceCheckUtils]: 53: Hoare triple {10143#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10150#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:20,267 INFO L273 TraceCheckUtils]: 54: Hoare triple {10150#(<= main_~i~0 36)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10321#(<= main_~i~0 43)} is VALID [2018-11-23 12:10:20,268 INFO L273 TraceCheckUtils]: 55: Hoare triple {10321#(<= main_~i~0 43)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10325#(<= main_~i~0 50)} is VALID [2018-11-23 12:10:20,269 INFO L273 TraceCheckUtils]: 56: Hoare triple {10325#(<= main_~i~0 50)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10329#(<= main_~i~0 57)} is VALID [2018-11-23 12:10:20,270 INFO L273 TraceCheckUtils]: 57: Hoare triple {10329#(<= main_~i~0 57)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10333#(<= main_~i~0 64)} is VALID [2018-11-23 12:10:20,271 INFO L273 TraceCheckUtils]: 58: Hoare triple {10333#(<= main_~i~0 64)} assume !(~i~0 < 100000); {10113#false} is VALID [2018-11-23 12:10:20,271 INFO L273 TraceCheckUtils]: 59: Hoare triple {10113#false} ~i~0 := 1;~j~0 := 0; {10113#false} is VALID [2018-11-23 12:10:20,271 INFO L273 TraceCheckUtils]: 60: Hoare triple {10113#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 + 7 * ~j~0), 4); {10113#false} is VALID [2018-11-23 12:10:20,272 INFO L256 TraceCheckUtils]: 61: Hoare triple {10113#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {10113#false} is VALID [2018-11-23 12:10:20,272 INFO L273 TraceCheckUtils]: 62: Hoare triple {10113#false} ~cond := #in~cond; {10113#false} is VALID [2018-11-23 12:10:20,272 INFO L273 TraceCheckUtils]: 63: Hoare triple {10113#false} assume 0 == ~cond; {10113#false} is VALID [2018-11-23 12:10:20,272 INFO L273 TraceCheckUtils]: 64: Hoare triple {10113#false} assume !false; {10113#false} is VALID [2018-11-23 12:10:20,275 INFO L134 CoverageAnalysis]: Checked inductivity of 906 backedges. 0 proven. 45 refuted. 0 times theorem prover too weak. 861 trivial. 0 not checked. [2018-11-23 12:10:20,302 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:20,302 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [44, 12] total 48 [2018-11-23 12:10:20,302 INFO L78 Accepts]: Start accepts. Automaton has 48 states. Word has length 65 [2018-11-23 12:10:20,302 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:20,303 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 48 states. [2018-11-23 12:10:20,424 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 71 edges. 71 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:20,425 INFO L459 AbstractCegarLoop]: Interpolant automaton has 48 states [2018-11-23 12:10:20,426 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 48 interpolants. [2018-11-23 12:10:20,427 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1128, Invalid=1128, Unknown=0, NotChecked=0, Total=2256 [2018-11-23 12:10:20,427 INFO L87 Difference]: Start difference. First operand 69 states and 71 transitions. Second operand 48 states. [2018-11-23 12:10:21,874 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:21,874 INFO L93 Difference]: Finished difference Result 126 states and 145 transitions. [2018-11-23 12:10:21,875 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 48 states. [2018-11-23 12:10:21,875 INFO L78 Accepts]: Start accepts. Automaton has 48 states. Word has length 65 [2018-11-23 12:10:21,875 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:21,875 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 48 states. [2018-11-23 12:10:21,877 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 48 states to 48 states and 136 transitions. [2018-11-23 12:10:21,878 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 48 states. [2018-11-23 12:10:21,880 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 48 states to 48 states and 136 transitions. [2018-11-23 12:10:21,880 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 48 states and 136 transitions. [2018-11-23 12:10:22,105 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 136 edges. 136 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:22,109 INFO L225 Difference]: With dead ends: 126 [2018-11-23 12:10:22,109 INFO L226 Difference]: Without dead ends: 105 [2018-11-23 12:10:22,111 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 108 GetRequests, 62 SyntacticMatches, 0 SemanticMatches, 46 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 1.0s TimeCoverageRelationStatistics Valid=1128, Invalid=1128, Unknown=0, NotChecked=0, Total=2256 [2018-11-23 12:10:22,111 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 105 states. [2018-11-23 12:10:22,184 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 105 to 75. [2018-11-23 12:10:22,184 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:22,184 INFO L82 GeneralOperation]: Start isEquivalent. First operand 105 states. Second operand 75 states. [2018-11-23 12:10:22,184 INFO L74 IsIncluded]: Start isIncluded. First operand 105 states. Second operand 75 states. [2018-11-23 12:10:22,185 INFO L87 Difference]: Start difference. First operand 105 states. Second operand 75 states. [2018-11-23 12:10:22,188 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:22,188 INFO L93 Difference]: Finished difference Result 105 states and 117 transitions. [2018-11-23 12:10:22,188 INFO L276 IsEmpty]: Start isEmpty. Operand 105 states and 117 transitions. [2018-11-23 12:10:22,189 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:22,189 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:22,190 INFO L74 IsIncluded]: Start isIncluded. First operand 75 states. Second operand 105 states. [2018-11-23 12:10:22,190 INFO L87 Difference]: Start difference. First operand 75 states. Second operand 105 states. [2018-11-23 12:10:22,192 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:22,192 INFO L93 Difference]: Finished difference Result 105 states and 117 transitions. [2018-11-23 12:10:22,193 INFO L276 IsEmpty]: Start isEmpty. Operand 105 states and 117 transitions. [2018-11-23 12:10:22,193 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:22,193 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:22,194 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:22,194 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:22,194 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 75 states. [2018-11-23 12:10:22,195 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 75 states to 75 states and 77 transitions. [2018-11-23 12:10:22,195 INFO L78 Accepts]: Start accepts. Automaton has 75 states and 77 transitions. Word has length 65 [2018-11-23 12:10:22,196 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:22,196 INFO L480 AbstractCegarLoop]: Abstraction has 75 states and 77 transitions. [2018-11-23 12:10:22,196 INFO L481 AbstractCegarLoop]: Interpolant automaton has 48 states. [2018-11-23 12:10:22,196 INFO L276 IsEmpty]: Start isEmpty. Operand 75 states and 77 transitions. [2018-11-23 12:10:22,197 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 72 [2018-11-23 12:10:22,197 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:22,197 INFO L402 BasicCegarLoop]: trace histogram [46, 10, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:22,197 INFO L423 AbstractCegarLoop]: === Iteration 27 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:22,198 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:22,198 INFO L82 PathProgramCache]: Analyzing trace with hash -219534074, now seen corresponding path program 24 times [2018-11-23 12:10:22,198 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:22,198 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:22,199 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:22,199 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:22,199 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:22,257 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:24,136 INFO L256 TraceCheckUtils]: 0: Hoare triple {10928#true} call ULTIMATE.init(); {10928#true} is VALID [2018-11-23 12:10:24,136 INFO L273 TraceCheckUtils]: 1: Hoare triple {10928#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {10928#true} is VALID [2018-11-23 12:10:24,137 INFO L273 TraceCheckUtils]: 2: Hoare triple {10928#true} assume true; {10928#true} is VALID [2018-11-23 12:10:24,137 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {10928#true} {10928#true} #60#return; {10928#true} is VALID [2018-11-23 12:10:24,137 INFO L256 TraceCheckUtils]: 4: Hoare triple {10928#true} call #t~ret4 := main(); {10928#true} is VALID [2018-11-23 12:10:24,137 INFO L273 TraceCheckUtils]: 5: Hoare triple {10928#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; {10930#(= main_~i~0 0)} is VALID [2018-11-23 12:10:24,139 INFO L273 TraceCheckUtils]: 6: Hoare triple {10930#(= 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; {10931#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:24,139 INFO L273 TraceCheckUtils]: 7: Hoare triple {10931#(<= 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; {10932#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:24,141 INFO L273 TraceCheckUtils]: 8: Hoare triple {10932#(<= 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; {10933#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:24,142 INFO L273 TraceCheckUtils]: 9: Hoare triple {10933#(<= 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; {10934#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:24,143 INFO L273 TraceCheckUtils]: 10: Hoare triple {10934#(<= 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; {10935#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:24,144 INFO L273 TraceCheckUtils]: 11: Hoare triple {10935#(<= 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; {10936#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:24,145 INFO L273 TraceCheckUtils]: 12: Hoare triple {10936#(<= 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; {10937#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:24,146 INFO L273 TraceCheckUtils]: 13: Hoare triple {10937#(<= 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; {10938#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:24,147 INFO L273 TraceCheckUtils]: 14: Hoare triple {10938#(<= 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; {10939#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:24,148 INFO L273 TraceCheckUtils]: 15: Hoare triple {10939#(<= 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; {10940#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:24,149 INFO L273 TraceCheckUtils]: 16: Hoare triple {10940#(<= 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; {10941#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:24,150 INFO L273 TraceCheckUtils]: 17: Hoare triple {10941#(<= 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; {10942#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:24,151 INFO L273 TraceCheckUtils]: 18: Hoare triple {10942#(<= 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; {10943#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:24,152 INFO L273 TraceCheckUtils]: 19: Hoare triple {10943#(<= 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; {10944#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:24,153 INFO L273 TraceCheckUtils]: 20: Hoare triple {10944#(<= 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; {10945#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:24,154 INFO L273 TraceCheckUtils]: 21: Hoare triple {10945#(<= 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; {10946#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:24,155 INFO L273 TraceCheckUtils]: 22: Hoare triple {10946#(<= 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; {10947#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:24,156 INFO L273 TraceCheckUtils]: 23: Hoare triple {10947#(<= 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; {10948#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:24,157 INFO L273 TraceCheckUtils]: 24: Hoare triple {10948#(<= 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; {10949#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:24,158 INFO L273 TraceCheckUtils]: 25: Hoare triple {10949#(<= 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; {10950#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:24,159 INFO L273 TraceCheckUtils]: 26: Hoare triple {10950#(<= 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; {10951#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:24,160 INFO L273 TraceCheckUtils]: 27: Hoare triple {10951#(<= 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; {10952#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:24,161 INFO L273 TraceCheckUtils]: 28: Hoare triple {10952#(<= 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; {10953#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:24,161 INFO L273 TraceCheckUtils]: 29: Hoare triple {10953#(<= 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; {10954#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:24,162 INFO L273 TraceCheckUtils]: 30: Hoare triple {10954#(<= 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; {10955#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:24,163 INFO L273 TraceCheckUtils]: 31: Hoare triple {10955#(<= 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; {10956#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:24,164 INFO L273 TraceCheckUtils]: 32: Hoare triple {10956#(<= 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; {10957#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:24,165 INFO L273 TraceCheckUtils]: 33: Hoare triple {10957#(<= 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; {10958#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:24,166 INFO L273 TraceCheckUtils]: 34: Hoare triple {10958#(<= 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; {10959#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:24,167 INFO L273 TraceCheckUtils]: 35: Hoare triple {10959#(<= 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; {10960#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:24,168 INFO L273 TraceCheckUtils]: 36: Hoare triple {10960#(<= 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; {10961#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:24,169 INFO L273 TraceCheckUtils]: 37: Hoare triple {10961#(<= 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; {10962#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:24,170 INFO L273 TraceCheckUtils]: 38: Hoare triple {10962#(<= 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; {10963#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:24,171 INFO L273 TraceCheckUtils]: 39: Hoare triple {10963#(<= 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; {10964#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:24,172 INFO L273 TraceCheckUtils]: 40: Hoare triple {10964#(<= 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; {10965#(<= main_~i~0 35)} is VALID [2018-11-23 12:10:24,173 INFO L273 TraceCheckUtils]: 41: Hoare triple {10965#(<= 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; {10966#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:24,174 INFO L273 TraceCheckUtils]: 42: Hoare triple {10966#(<= 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; {10967#(<= main_~i~0 37)} is VALID [2018-11-23 12:10:24,175 INFO L273 TraceCheckUtils]: 43: Hoare triple {10967#(<= 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; {10968#(<= main_~i~0 38)} is VALID [2018-11-23 12:10:24,176 INFO L273 TraceCheckUtils]: 44: Hoare triple {10968#(<= 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; {10969#(<= main_~i~0 39)} is VALID [2018-11-23 12:10:24,177 INFO L273 TraceCheckUtils]: 45: Hoare triple {10969#(<= 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; {10970#(<= main_~i~0 40)} is VALID [2018-11-23 12:10:24,178 INFO L273 TraceCheckUtils]: 46: Hoare triple {10970#(<= 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; {10971#(<= main_~i~0 41)} is VALID [2018-11-23 12:10:24,179 INFO L273 TraceCheckUtils]: 47: Hoare triple {10971#(<= 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; {10972#(<= main_~i~0 42)} is VALID [2018-11-23 12:10:24,180 INFO L273 TraceCheckUtils]: 48: Hoare triple {10972#(<= 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; {10973#(<= main_~i~0 43)} is VALID [2018-11-23 12:10:24,181 INFO L273 TraceCheckUtils]: 49: Hoare triple {10973#(<= 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; {10974#(<= main_~i~0 44)} is VALID [2018-11-23 12:10:24,182 INFO L273 TraceCheckUtils]: 50: Hoare triple {10974#(<= 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; {10975#(<= main_~i~0 45)} is VALID [2018-11-23 12:10:24,183 INFO L273 TraceCheckUtils]: 51: Hoare triple {10975#(<= 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; {10976#(<= main_~i~0 46)} is VALID [2018-11-23 12:10:24,184 INFO L273 TraceCheckUtils]: 52: Hoare triple {10976#(<= main_~i~0 46)} assume !(~i~0 < 100000); {10929#false} is VALID [2018-11-23 12:10:24,184 INFO L273 TraceCheckUtils]: 53: Hoare triple {10929#false} ~i~0 := 1; {10929#false} is VALID [2018-11-23 12:10:24,184 INFO L273 TraceCheckUtils]: 54: Hoare triple {10929#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10929#false} is VALID [2018-11-23 12:10:24,184 INFO L273 TraceCheckUtils]: 55: Hoare triple {10929#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10929#false} is VALID [2018-11-23 12:10:24,185 INFO L273 TraceCheckUtils]: 56: Hoare triple {10929#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10929#false} is VALID [2018-11-23 12:10:24,185 INFO L273 TraceCheckUtils]: 57: Hoare triple {10929#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10929#false} is VALID [2018-11-23 12:10:24,185 INFO L273 TraceCheckUtils]: 58: Hoare triple {10929#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10929#false} is VALID [2018-11-23 12:10:24,185 INFO L273 TraceCheckUtils]: 59: Hoare triple {10929#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10929#false} is VALID [2018-11-23 12:10:24,185 INFO L273 TraceCheckUtils]: 60: Hoare triple {10929#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10929#false} is VALID [2018-11-23 12:10:24,186 INFO L273 TraceCheckUtils]: 61: Hoare triple {10929#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10929#false} is VALID [2018-11-23 12:10:24,186 INFO L273 TraceCheckUtils]: 62: Hoare triple {10929#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10929#false} is VALID [2018-11-23 12:10:24,186 INFO L273 TraceCheckUtils]: 63: Hoare triple {10929#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10929#false} is VALID [2018-11-23 12:10:24,186 INFO L273 TraceCheckUtils]: 64: Hoare triple {10929#false} assume !(~i~0 < 100000); {10929#false} is VALID [2018-11-23 12:10:24,186 INFO L273 TraceCheckUtils]: 65: Hoare triple {10929#false} ~i~0 := 1;~j~0 := 0; {10929#false} is VALID [2018-11-23 12:10:24,186 INFO L273 TraceCheckUtils]: 66: Hoare triple {10929#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 + 7 * ~j~0), 4); {10929#false} is VALID [2018-11-23 12:10:24,187 INFO L256 TraceCheckUtils]: 67: Hoare triple {10929#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {10929#false} is VALID [2018-11-23 12:10:24,187 INFO L273 TraceCheckUtils]: 68: Hoare triple {10929#false} ~cond := #in~cond; {10929#false} is VALID [2018-11-23 12:10:24,187 INFO L273 TraceCheckUtils]: 69: Hoare triple {10929#false} assume 0 == ~cond; {10929#false} is VALID [2018-11-23 12:10:24,187 INFO L273 TraceCheckUtils]: 70: Hoare triple {10929#false} assume !false; {10929#false} is VALID [2018-11-23 12:10:24,190 INFO L134 CoverageAnalysis]: Checked inductivity of 1136 backedges. 0 proven. 1081 refuted. 0 times theorem prover too weak. 55 trivial. 0 not checked. [2018-11-23 12:10:24,191 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:24,191 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:10:24,201 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE [2018-11-23 12:10:27,163 INFO L249 tOrderPrioritization]: Assert order MIX_INSIDE_OUTSIDE issued 11 check-sat command(s) [2018-11-23 12:10:27,163 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:27,184 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:27,185 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:27,415 INFO L256 TraceCheckUtils]: 0: Hoare triple {10928#true} call ULTIMATE.init(); {10928#true} is VALID [2018-11-23 12:10:27,416 INFO L273 TraceCheckUtils]: 1: Hoare triple {10928#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {10928#true} is VALID [2018-11-23 12:10:27,416 INFO L273 TraceCheckUtils]: 2: Hoare triple {10928#true} assume true; {10928#true} is VALID [2018-11-23 12:10:27,416 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {10928#true} {10928#true} #60#return; {10928#true} is VALID [2018-11-23 12:10:27,416 INFO L256 TraceCheckUtils]: 4: Hoare triple {10928#true} call #t~ret4 := main(); {10928#true} is VALID [2018-11-23 12:10:27,416 INFO L273 TraceCheckUtils]: 5: Hoare triple {10928#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; {10928#true} is VALID [2018-11-23 12:10:27,417 INFO L273 TraceCheckUtils]: 6: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,417 INFO L273 TraceCheckUtils]: 7: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,417 INFO L273 TraceCheckUtils]: 8: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,417 INFO L273 TraceCheckUtils]: 9: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,417 INFO L273 TraceCheckUtils]: 10: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,418 INFO L273 TraceCheckUtils]: 11: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,418 INFO L273 TraceCheckUtils]: 12: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,418 INFO L273 TraceCheckUtils]: 13: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,418 INFO L273 TraceCheckUtils]: 14: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,418 INFO L273 TraceCheckUtils]: 15: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,418 INFO L273 TraceCheckUtils]: 16: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,419 INFO L273 TraceCheckUtils]: 17: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,419 INFO L273 TraceCheckUtils]: 18: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,419 INFO L273 TraceCheckUtils]: 19: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,419 INFO L273 TraceCheckUtils]: 20: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,419 INFO L273 TraceCheckUtils]: 21: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,420 INFO L273 TraceCheckUtils]: 22: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,420 INFO L273 TraceCheckUtils]: 23: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,420 INFO L273 TraceCheckUtils]: 24: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,420 INFO L273 TraceCheckUtils]: 25: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,420 INFO L273 TraceCheckUtils]: 26: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,420 INFO L273 TraceCheckUtils]: 27: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,420 INFO L273 TraceCheckUtils]: 28: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,420 INFO L273 TraceCheckUtils]: 29: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,421 INFO L273 TraceCheckUtils]: 30: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,421 INFO L273 TraceCheckUtils]: 31: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,421 INFO L273 TraceCheckUtils]: 32: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,421 INFO L273 TraceCheckUtils]: 33: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,421 INFO L273 TraceCheckUtils]: 34: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,421 INFO L273 TraceCheckUtils]: 35: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,421 INFO L273 TraceCheckUtils]: 36: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,421 INFO L273 TraceCheckUtils]: 37: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,421 INFO L273 TraceCheckUtils]: 38: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,422 INFO L273 TraceCheckUtils]: 39: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,422 INFO L273 TraceCheckUtils]: 40: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,422 INFO L273 TraceCheckUtils]: 41: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,422 INFO L273 TraceCheckUtils]: 42: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,422 INFO L273 TraceCheckUtils]: 43: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,422 INFO L273 TraceCheckUtils]: 44: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,422 INFO L273 TraceCheckUtils]: 45: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,422 INFO L273 TraceCheckUtils]: 46: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,422 INFO L273 TraceCheckUtils]: 47: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,423 INFO L273 TraceCheckUtils]: 48: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,423 INFO L273 TraceCheckUtils]: 49: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,423 INFO L273 TraceCheckUtils]: 50: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,423 INFO L273 TraceCheckUtils]: 51: Hoare triple {10928#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {10928#true} is VALID [2018-11-23 12:10:27,423 INFO L273 TraceCheckUtils]: 52: Hoare triple {10928#true} assume !(~i~0 < 100000); {10928#true} is VALID [2018-11-23 12:10:27,423 INFO L273 TraceCheckUtils]: 53: Hoare triple {10928#true} ~i~0 := 1; {10931#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:27,424 INFO L273 TraceCheckUtils]: 54: Hoare triple {10931#(<= 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10938#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:27,425 INFO L273 TraceCheckUtils]: 55: Hoare triple {10938#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10945#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:27,425 INFO L273 TraceCheckUtils]: 56: Hoare triple {10945#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10952#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:27,426 INFO L273 TraceCheckUtils]: 57: Hoare triple {10952#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10959#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:27,427 INFO L273 TraceCheckUtils]: 58: Hoare triple {10959#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10966#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:27,427 INFO L273 TraceCheckUtils]: 59: Hoare triple {10966#(<= main_~i~0 36)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {10973#(<= main_~i~0 43)} is VALID [2018-11-23 12:10:27,428 INFO L273 TraceCheckUtils]: 60: Hoare triple {10973#(<= main_~i~0 43)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11160#(<= main_~i~0 50)} is VALID [2018-11-23 12:10:27,428 INFO L273 TraceCheckUtils]: 61: Hoare triple {11160#(<= main_~i~0 50)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11164#(<= main_~i~0 57)} is VALID [2018-11-23 12:10:27,429 INFO L273 TraceCheckUtils]: 62: Hoare triple {11164#(<= main_~i~0 57)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11168#(<= main_~i~0 64)} is VALID [2018-11-23 12:10:27,430 INFO L273 TraceCheckUtils]: 63: Hoare triple {11168#(<= 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11172#(<= main_~i~0 71)} is VALID [2018-11-23 12:10:27,431 INFO L273 TraceCheckUtils]: 64: Hoare triple {11172#(<= main_~i~0 71)} assume !(~i~0 < 100000); {10929#false} is VALID [2018-11-23 12:10:27,431 INFO L273 TraceCheckUtils]: 65: Hoare triple {10929#false} ~i~0 := 1;~j~0 := 0; {10929#false} is VALID [2018-11-23 12:10:27,431 INFO L273 TraceCheckUtils]: 66: Hoare triple {10929#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 + 7 * ~j~0), 4); {10929#false} is VALID [2018-11-23 12:10:27,431 INFO L256 TraceCheckUtils]: 67: Hoare triple {10929#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {10929#false} is VALID [2018-11-23 12:10:27,432 INFO L273 TraceCheckUtils]: 68: Hoare triple {10929#false} ~cond := #in~cond; {10929#false} is VALID [2018-11-23 12:10:27,432 INFO L273 TraceCheckUtils]: 69: Hoare triple {10929#false} assume 0 == ~cond; {10929#false} is VALID [2018-11-23 12:10:27,432 INFO L273 TraceCheckUtils]: 70: Hoare triple {10929#false} assume !false; {10929#false} is VALID [2018-11-23 12:10:27,435 INFO L134 CoverageAnalysis]: Checked inductivity of 1136 backedges. 0 proven. 55 refuted. 0 times theorem prover too weak. 1081 trivial. 0 not checked. [2018-11-23 12:10:27,457 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:27,457 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [49, 13] total 53 [2018-11-23 12:10:27,458 INFO L78 Accepts]: Start accepts. Automaton has 53 states. Word has length 71 [2018-11-23 12:10:27,458 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:27,458 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 53 states. [2018-11-23 12:10:27,519 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:10:27,519 INFO L459 AbstractCegarLoop]: Interpolant automaton has 53 states [2018-11-23 12:10:27,520 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 53 interpolants. [2018-11-23 12:10:27,522 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1378, Invalid=1378, Unknown=0, NotChecked=0, Total=2756 [2018-11-23 12:10:27,522 INFO L87 Difference]: Start difference. First operand 75 states and 77 transitions. Second operand 53 states. [2018-11-23 12:10:29,264 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:29,264 INFO L93 Difference]: Finished difference Result 136 states and 156 transitions. [2018-11-23 12:10:29,264 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 53 states. [2018-11-23 12:10:29,264 INFO L78 Accepts]: Start accepts. Automaton has 53 states. Word has length 71 [2018-11-23 12:10:29,265 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:29,265 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 53 states. [2018-11-23 12:10:29,266 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 53 states to 53 states and 146 transitions. [2018-11-23 12:10:29,267 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 53 states. [2018-11-23 12:10:29,268 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 53 states to 53 states and 146 transitions. [2018-11-23 12:10:29,268 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 53 states and 146 transitions. [2018-11-23 12:10:29,406 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 146 edges. 146 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:29,408 INFO L225 Difference]: With dead ends: 136 [2018-11-23 12:10:29,408 INFO L226 Difference]: Without dead ends: 114 [2018-11-23 12:10:29,410 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 119 GetRequests, 68 SyntacticMatches, 0 SemanticMatches, 51 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 1.7s TimeCoverageRelationStatistics Valid=1378, Invalid=1378, Unknown=0, NotChecked=0, Total=2756 [2018-11-23 12:10:29,410 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 114 states. [2018-11-23 12:10:29,498 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 114 to 81. [2018-11-23 12:10:29,498 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:29,499 INFO L82 GeneralOperation]: Start isEquivalent. First operand 114 states. Second operand 81 states. [2018-11-23 12:10:29,499 INFO L74 IsIncluded]: Start isIncluded. First operand 114 states. Second operand 81 states. [2018-11-23 12:10:29,499 INFO L87 Difference]: Start difference. First operand 114 states. Second operand 81 states. [2018-11-23 12:10:29,502 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:29,502 INFO L93 Difference]: Finished difference Result 114 states and 127 transitions. [2018-11-23 12:10:29,502 INFO L276 IsEmpty]: Start isEmpty. Operand 114 states and 127 transitions. [2018-11-23 12:10:29,503 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:29,503 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:29,503 INFO L74 IsIncluded]: Start isIncluded. First operand 81 states. Second operand 114 states. [2018-11-23 12:10:29,503 INFO L87 Difference]: Start difference. First operand 81 states. Second operand 114 states. [2018-11-23 12:10:29,505 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:29,506 INFO L93 Difference]: Finished difference Result 114 states and 127 transitions. [2018-11-23 12:10:29,506 INFO L276 IsEmpty]: Start isEmpty. Operand 114 states and 127 transitions. [2018-11-23 12:10:29,506 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:29,507 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:29,507 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:29,507 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:29,507 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 81 states. [2018-11-23 12:10:29,508 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 81 states to 81 states and 83 transitions. [2018-11-23 12:10:29,508 INFO L78 Accepts]: Start accepts. Automaton has 81 states and 83 transitions. Word has length 71 [2018-11-23 12:10:29,509 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:29,509 INFO L480 AbstractCegarLoop]: Abstraction has 81 states and 83 transitions. [2018-11-23 12:10:29,509 INFO L481 AbstractCegarLoop]: Interpolant automaton has 53 states. [2018-11-23 12:10:29,509 INFO L276 IsEmpty]: Start isEmpty. Operand 81 states and 83 transitions. [2018-11-23 12:10:29,509 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 78 [2018-11-23 12:10:29,510 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:29,510 INFO L402 BasicCegarLoop]: trace histogram [51, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:29,510 INFO L423 AbstractCegarLoop]: === Iteration 28 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:29,510 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:29,510 INFO L82 PathProgramCache]: Analyzing trace with hash -1163564187, now seen corresponding path program 25 times [2018-11-23 12:10:29,511 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:29,511 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:29,511 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:29,511 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:29,512 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:29,571 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:31,244 INFO L256 TraceCheckUtils]: 0: Hoare triple {11816#true} call ULTIMATE.init(); {11816#true} is VALID [2018-11-23 12:10:31,244 INFO L273 TraceCheckUtils]: 1: Hoare triple {11816#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {11816#true} is VALID [2018-11-23 12:10:31,244 INFO L273 TraceCheckUtils]: 2: Hoare triple {11816#true} assume true; {11816#true} is VALID [2018-11-23 12:10:31,244 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {11816#true} {11816#true} #60#return; {11816#true} is VALID [2018-11-23 12:10:31,245 INFO L256 TraceCheckUtils]: 4: Hoare triple {11816#true} call #t~ret4 := main(); {11816#true} is VALID [2018-11-23 12:10:31,245 INFO L273 TraceCheckUtils]: 5: Hoare triple {11816#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; {11818#(= main_~i~0 0)} is VALID [2018-11-23 12:10:31,246 INFO L273 TraceCheckUtils]: 6: Hoare triple {11818#(= 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; {11819#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:31,247 INFO L273 TraceCheckUtils]: 7: Hoare triple {11819#(<= 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; {11820#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:31,247 INFO L273 TraceCheckUtils]: 8: Hoare triple {11820#(<= 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; {11821#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:31,248 INFO L273 TraceCheckUtils]: 9: Hoare triple {11821#(<= 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; {11822#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:31,248 INFO L273 TraceCheckUtils]: 10: Hoare triple {11822#(<= 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; {11823#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:31,249 INFO L273 TraceCheckUtils]: 11: Hoare triple {11823#(<= 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; {11824#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:31,250 INFO L273 TraceCheckUtils]: 12: Hoare triple {11824#(<= 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; {11825#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:31,251 INFO L273 TraceCheckUtils]: 13: Hoare triple {11825#(<= 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; {11826#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:31,252 INFO L273 TraceCheckUtils]: 14: Hoare triple {11826#(<= 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; {11827#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:31,253 INFO L273 TraceCheckUtils]: 15: Hoare triple {11827#(<= 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; {11828#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:31,254 INFO L273 TraceCheckUtils]: 16: Hoare triple {11828#(<= 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; {11829#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:31,255 INFO L273 TraceCheckUtils]: 17: Hoare triple {11829#(<= 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; {11830#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:31,256 INFO L273 TraceCheckUtils]: 18: Hoare triple {11830#(<= 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; {11831#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:31,257 INFO L273 TraceCheckUtils]: 19: Hoare triple {11831#(<= 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; {11832#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:31,257 INFO L273 TraceCheckUtils]: 20: Hoare triple {11832#(<= 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; {11833#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:31,258 INFO L273 TraceCheckUtils]: 21: Hoare triple {11833#(<= 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; {11834#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:31,259 INFO L273 TraceCheckUtils]: 22: Hoare triple {11834#(<= 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; {11835#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:31,260 INFO L273 TraceCheckUtils]: 23: Hoare triple {11835#(<= 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; {11836#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:31,261 INFO L273 TraceCheckUtils]: 24: Hoare triple {11836#(<= 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; {11837#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:31,262 INFO L273 TraceCheckUtils]: 25: Hoare triple {11837#(<= 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; {11838#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:31,263 INFO L273 TraceCheckUtils]: 26: Hoare triple {11838#(<= 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; {11839#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:31,264 INFO L273 TraceCheckUtils]: 27: Hoare triple {11839#(<= 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; {11840#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:31,265 INFO L273 TraceCheckUtils]: 28: Hoare triple {11840#(<= 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; {11841#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:31,266 INFO L273 TraceCheckUtils]: 29: Hoare triple {11841#(<= 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; {11842#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:31,267 INFO L273 TraceCheckUtils]: 30: Hoare triple {11842#(<= 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; {11843#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:31,268 INFO L273 TraceCheckUtils]: 31: Hoare triple {11843#(<= 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; {11844#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:31,269 INFO L273 TraceCheckUtils]: 32: Hoare triple {11844#(<= 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; {11845#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:31,270 INFO L273 TraceCheckUtils]: 33: Hoare triple {11845#(<= 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; {11846#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:31,270 INFO L273 TraceCheckUtils]: 34: Hoare triple {11846#(<= 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; {11847#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:31,271 INFO L273 TraceCheckUtils]: 35: Hoare triple {11847#(<= 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; {11848#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:31,272 INFO L273 TraceCheckUtils]: 36: Hoare triple {11848#(<= 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; {11849#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:31,273 INFO L273 TraceCheckUtils]: 37: Hoare triple {11849#(<= 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; {11850#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:31,274 INFO L273 TraceCheckUtils]: 38: Hoare triple {11850#(<= 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; {11851#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:31,275 INFO L273 TraceCheckUtils]: 39: Hoare triple {11851#(<= 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; {11852#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:31,276 INFO L273 TraceCheckUtils]: 40: Hoare triple {11852#(<= 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; {11853#(<= main_~i~0 35)} is VALID [2018-11-23 12:10:31,277 INFO L273 TraceCheckUtils]: 41: Hoare triple {11853#(<= 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; {11854#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:31,278 INFO L273 TraceCheckUtils]: 42: Hoare triple {11854#(<= 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; {11855#(<= main_~i~0 37)} is VALID [2018-11-23 12:10:31,279 INFO L273 TraceCheckUtils]: 43: Hoare triple {11855#(<= 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; {11856#(<= main_~i~0 38)} is VALID [2018-11-23 12:10:31,280 INFO L273 TraceCheckUtils]: 44: Hoare triple {11856#(<= 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; {11857#(<= main_~i~0 39)} is VALID [2018-11-23 12:10:31,281 INFO L273 TraceCheckUtils]: 45: Hoare triple {11857#(<= 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; {11858#(<= main_~i~0 40)} is VALID [2018-11-23 12:10:31,282 INFO L273 TraceCheckUtils]: 46: Hoare triple {11858#(<= 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; {11859#(<= main_~i~0 41)} is VALID [2018-11-23 12:10:31,283 INFO L273 TraceCheckUtils]: 47: Hoare triple {11859#(<= 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; {11860#(<= main_~i~0 42)} is VALID [2018-11-23 12:10:31,283 INFO L273 TraceCheckUtils]: 48: Hoare triple {11860#(<= 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; {11861#(<= main_~i~0 43)} is VALID [2018-11-23 12:10:31,284 INFO L273 TraceCheckUtils]: 49: Hoare triple {11861#(<= 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; {11862#(<= main_~i~0 44)} is VALID [2018-11-23 12:10:31,285 INFO L273 TraceCheckUtils]: 50: Hoare triple {11862#(<= 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; {11863#(<= main_~i~0 45)} is VALID [2018-11-23 12:10:31,286 INFO L273 TraceCheckUtils]: 51: Hoare triple {11863#(<= 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; {11864#(<= main_~i~0 46)} is VALID [2018-11-23 12:10:31,287 INFO L273 TraceCheckUtils]: 52: Hoare triple {11864#(<= 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; {11865#(<= main_~i~0 47)} is VALID [2018-11-23 12:10:31,288 INFO L273 TraceCheckUtils]: 53: Hoare triple {11865#(<= 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; {11866#(<= main_~i~0 48)} is VALID [2018-11-23 12:10:31,289 INFO L273 TraceCheckUtils]: 54: Hoare triple {11866#(<= 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; {11867#(<= main_~i~0 49)} is VALID [2018-11-23 12:10:31,290 INFO L273 TraceCheckUtils]: 55: Hoare triple {11867#(<= 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; {11868#(<= main_~i~0 50)} is VALID [2018-11-23 12:10:31,291 INFO L273 TraceCheckUtils]: 56: Hoare triple {11868#(<= 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; {11869#(<= main_~i~0 51)} is VALID [2018-11-23 12:10:31,292 INFO L273 TraceCheckUtils]: 57: Hoare triple {11869#(<= main_~i~0 51)} assume !(~i~0 < 100000); {11817#false} is VALID [2018-11-23 12:10:31,292 INFO L273 TraceCheckUtils]: 58: Hoare triple {11817#false} ~i~0 := 1; {11817#false} is VALID [2018-11-23 12:10:31,292 INFO L273 TraceCheckUtils]: 59: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,292 INFO L273 TraceCheckUtils]: 60: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,292 INFO L273 TraceCheckUtils]: 61: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,293 INFO L273 TraceCheckUtils]: 62: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,293 INFO L273 TraceCheckUtils]: 63: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,293 INFO L273 TraceCheckUtils]: 64: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,293 INFO L273 TraceCheckUtils]: 65: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,293 INFO L273 TraceCheckUtils]: 66: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,294 INFO L273 TraceCheckUtils]: 67: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,294 INFO L273 TraceCheckUtils]: 68: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,294 INFO L273 TraceCheckUtils]: 69: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,294 INFO L273 TraceCheckUtils]: 70: Hoare triple {11817#false} assume !(~i~0 < 100000); {11817#false} is VALID [2018-11-23 12:10:31,294 INFO L273 TraceCheckUtils]: 71: Hoare triple {11817#false} ~i~0 := 1;~j~0 := 0; {11817#false} is VALID [2018-11-23 12:10:31,295 INFO L273 TraceCheckUtils]: 72: Hoare triple {11817#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 + 7 * ~j~0), 4); {11817#false} is VALID [2018-11-23 12:10:31,295 INFO L256 TraceCheckUtils]: 73: Hoare triple {11817#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {11817#false} is VALID [2018-11-23 12:10:31,295 INFO L273 TraceCheckUtils]: 74: Hoare triple {11817#false} ~cond := #in~cond; {11817#false} is VALID [2018-11-23 12:10:31,295 INFO L273 TraceCheckUtils]: 75: Hoare triple {11817#false} assume 0 == ~cond; {11817#false} is VALID [2018-11-23 12:10:31,295 INFO L273 TraceCheckUtils]: 76: Hoare triple {11817#false} assume !false; {11817#false} is VALID [2018-11-23 12:10:31,301 INFO L134 CoverageAnalysis]: Checked inductivity of 1392 backedges. 0 proven. 1326 refuted. 0 times theorem prover too weak. 66 trivial. 0 not checked. [2018-11-23 12:10:31,301 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:31,301 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:10:31,310 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:10:31,376 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:31,404 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:31,406 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:31,707 INFO L256 TraceCheckUtils]: 0: Hoare triple {11816#true} call ULTIMATE.init(); {11816#true} is VALID [2018-11-23 12:10:31,707 INFO L273 TraceCheckUtils]: 1: Hoare triple {11816#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {11816#true} is VALID [2018-11-23 12:10:31,707 INFO L273 TraceCheckUtils]: 2: Hoare triple {11816#true} assume true; {11816#true} is VALID [2018-11-23 12:10:31,708 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {11816#true} {11816#true} #60#return; {11816#true} is VALID [2018-11-23 12:10:31,708 INFO L256 TraceCheckUtils]: 4: Hoare triple {11816#true} call #t~ret4 := main(); {11816#true} is VALID [2018-11-23 12:10:31,709 INFO L273 TraceCheckUtils]: 5: Hoare triple {11816#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; {11888#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:31,710 INFO L273 TraceCheckUtils]: 6: Hoare triple {11888#(<= 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; {11819#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:31,711 INFO L273 TraceCheckUtils]: 7: Hoare triple {11819#(<= 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; {11820#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:31,712 INFO L273 TraceCheckUtils]: 8: Hoare triple {11820#(<= 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; {11821#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:31,713 INFO L273 TraceCheckUtils]: 9: Hoare triple {11821#(<= 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; {11822#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:31,713 INFO L273 TraceCheckUtils]: 10: Hoare triple {11822#(<= 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; {11823#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:31,714 INFO L273 TraceCheckUtils]: 11: Hoare triple {11823#(<= 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; {11824#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:31,715 INFO L273 TraceCheckUtils]: 12: Hoare triple {11824#(<= 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; {11825#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:31,716 INFO L273 TraceCheckUtils]: 13: Hoare triple {11825#(<= 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; {11826#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:31,717 INFO L273 TraceCheckUtils]: 14: Hoare triple {11826#(<= 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; {11827#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:31,718 INFO L273 TraceCheckUtils]: 15: Hoare triple {11827#(<= 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; {11828#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:31,719 INFO L273 TraceCheckUtils]: 16: Hoare triple {11828#(<= 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; {11829#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:31,720 INFO L273 TraceCheckUtils]: 17: Hoare triple {11829#(<= 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; {11830#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:31,721 INFO L273 TraceCheckUtils]: 18: Hoare triple {11830#(<= 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; {11831#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:31,722 INFO L273 TraceCheckUtils]: 19: Hoare triple {11831#(<= 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; {11832#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:31,723 INFO L273 TraceCheckUtils]: 20: Hoare triple {11832#(<= 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; {11833#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:31,724 INFO L273 TraceCheckUtils]: 21: Hoare triple {11833#(<= 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; {11834#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:31,725 INFO L273 TraceCheckUtils]: 22: Hoare triple {11834#(<= 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; {11835#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:31,726 INFO L273 TraceCheckUtils]: 23: Hoare triple {11835#(<= 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; {11836#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:31,727 INFO L273 TraceCheckUtils]: 24: Hoare triple {11836#(<= 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; {11837#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:31,728 INFO L273 TraceCheckUtils]: 25: Hoare triple {11837#(<= 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; {11838#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:31,729 INFO L273 TraceCheckUtils]: 26: Hoare triple {11838#(<= 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; {11839#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:31,730 INFO L273 TraceCheckUtils]: 27: Hoare triple {11839#(<= 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; {11840#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:31,731 INFO L273 TraceCheckUtils]: 28: Hoare triple {11840#(<= 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; {11841#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:31,731 INFO L273 TraceCheckUtils]: 29: Hoare triple {11841#(<= 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; {11842#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:31,732 INFO L273 TraceCheckUtils]: 30: Hoare triple {11842#(<= 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; {11843#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:31,733 INFO L273 TraceCheckUtils]: 31: Hoare triple {11843#(<= 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; {11844#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:31,734 INFO L273 TraceCheckUtils]: 32: Hoare triple {11844#(<= 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; {11845#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:31,735 INFO L273 TraceCheckUtils]: 33: Hoare triple {11845#(<= 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; {11846#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:31,736 INFO L273 TraceCheckUtils]: 34: Hoare triple {11846#(<= 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; {11847#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:31,737 INFO L273 TraceCheckUtils]: 35: Hoare triple {11847#(<= 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; {11848#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:31,738 INFO L273 TraceCheckUtils]: 36: Hoare triple {11848#(<= 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; {11849#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:31,739 INFO L273 TraceCheckUtils]: 37: Hoare triple {11849#(<= 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; {11850#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:31,740 INFO L273 TraceCheckUtils]: 38: Hoare triple {11850#(<= 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; {11851#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:31,766 INFO L273 TraceCheckUtils]: 39: Hoare triple {11851#(<= 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; {11852#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:31,768 INFO L273 TraceCheckUtils]: 40: Hoare triple {11852#(<= 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; {11853#(<= main_~i~0 35)} is VALID [2018-11-23 12:10:31,768 INFO L273 TraceCheckUtils]: 41: Hoare triple {11853#(<= 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; {11854#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:31,770 INFO L273 TraceCheckUtils]: 42: Hoare triple {11854#(<= 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; {11855#(<= main_~i~0 37)} is VALID [2018-11-23 12:10:31,770 INFO L273 TraceCheckUtils]: 43: Hoare triple {11855#(<= 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; {11856#(<= main_~i~0 38)} is VALID [2018-11-23 12:10:31,772 INFO L273 TraceCheckUtils]: 44: Hoare triple {11856#(<= 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; {11857#(<= main_~i~0 39)} is VALID [2018-11-23 12:10:31,773 INFO L273 TraceCheckUtils]: 45: Hoare triple {11857#(<= 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; {11858#(<= main_~i~0 40)} is VALID [2018-11-23 12:10:31,774 INFO L273 TraceCheckUtils]: 46: Hoare triple {11858#(<= 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; {11859#(<= main_~i~0 41)} is VALID [2018-11-23 12:10:31,774 INFO L273 TraceCheckUtils]: 47: Hoare triple {11859#(<= 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; {11860#(<= main_~i~0 42)} is VALID [2018-11-23 12:10:31,775 INFO L273 TraceCheckUtils]: 48: Hoare triple {11860#(<= 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; {11861#(<= main_~i~0 43)} is VALID [2018-11-23 12:10:31,775 INFO L273 TraceCheckUtils]: 49: Hoare triple {11861#(<= 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; {11862#(<= main_~i~0 44)} is VALID [2018-11-23 12:10:31,776 INFO L273 TraceCheckUtils]: 50: Hoare triple {11862#(<= 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; {11863#(<= main_~i~0 45)} is VALID [2018-11-23 12:10:31,777 INFO L273 TraceCheckUtils]: 51: Hoare triple {11863#(<= 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; {11864#(<= main_~i~0 46)} is VALID [2018-11-23 12:10:31,778 INFO L273 TraceCheckUtils]: 52: Hoare triple {11864#(<= 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; {11865#(<= main_~i~0 47)} is VALID [2018-11-23 12:10:31,779 INFO L273 TraceCheckUtils]: 53: Hoare triple {11865#(<= 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; {11866#(<= main_~i~0 48)} is VALID [2018-11-23 12:10:31,780 INFO L273 TraceCheckUtils]: 54: Hoare triple {11866#(<= 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; {11867#(<= main_~i~0 49)} is VALID [2018-11-23 12:10:31,781 INFO L273 TraceCheckUtils]: 55: Hoare triple {11867#(<= 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; {11868#(<= main_~i~0 50)} is VALID [2018-11-23 12:10:31,782 INFO L273 TraceCheckUtils]: 56: Hoare triple {11868#(<= 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; {11869#(<= main_~i~0 51)} is VALID [2018-11-23 12:10:31,782 INFO L273 TraceCheckUtils]: 57: Hoare triple {11869#(<= main_~i~0 51)} assume !(~i~0 < 100000); {11817#false} is VALID [2018-11-23 12:10:31,783 INFO L273 TraceCheckUtils]: 58: Hoare triple {11817#false} ~i~0 := 1; {11817#false} is VALID [2018-11-23 12:10:31,783 INFO L273 TraceCheckUtils]: 59: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,783 INFO L273 TraceCheckUtils]: 60: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,783 INFO L273 TraceCheckUtils]: 61: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,783 INFO L273 TraceCheckUtils]: 62: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,783 INFO L273 TraceCheckUtils]: 63: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,784 INFO L273 TraceCheckUtils]: 64: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,784 INFO L273 TraceCheckUtils]: 65: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,784 INFO L273 TraceCheckUtils]: 66: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,784 INFO L273 TraceCheckUtils]: 67: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,784 INFO L273 TraceCheckUtils]: 68: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,785 INFO L273 TraceCheckUtils]: 69: Hoare triple {11817#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {11817#false} is VALID [2018-11-23 12:10:31,785 INFO L273 TraceCheckUtils]: 70: Hoare triple {11817#false} assume !(~i~0 < 100000); {11817#false} is VALID [2018-11-23 12:10:31,785 INFO L273 TraceCheckUtils]: 71: Hoare triple {11817#false} ~i~0 := 1;~j~0 := 0; {11817#false} is VALID [2018-11-23 12:10:31,785 INFO L273 TraceCheckUtils]: 72: Hoare triple {11817#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 + 7 * ~j~0), 4); {11817#false} is VALID [2018-11-23 12:10:31,785 INFO L256 TraceCheckUtils]: 73: Hoare triple {11817#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {11817#false} is VALID [2018-11-23 12:10:31,786 INFO L273 TraceCheckUtils]: 74: Hoare triple {11817#false} ~cond := #in~cond; {11817#false} is VALID [2018-11-23 12:10:31,786 INFO L273 TraceCheckUtils]: 75: Hoare triple {11817#false} assume 0 == ~cond; {11817#false} is VALID [2018-11-23 12:10:31,786 INFO L273 TraceCheckUtils]: 76: Hoare triple {11817#false} assume !false; {11817#false} is VALID [2018-11-23 12:10:31,791 INFO L134 CoverageAnalysis]: Checked inductivity of 1392 backedges. 0 proven. 1326 refuted. 0 times theorem prover too weak. 66 trivial. 0 not checked. [2018-11-23 12:10:31,810 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:31,810 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [54, 54] total 55 [2018-11-23 12:10:31,810 INFO L78 Accepts]: Start accepts. Automaton has 55 states. Word has length 77 [2018-11-23 12:10:31,811 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:31,811 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 55 states. [2018-11-23 12:10:31,861 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:10:31,862 INFO L459 AbstractCegarLoop]: Interpolant automaton has 55 states [2018-11-23 12:10:31,862 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 55 interpolants. [2018-11-23 12:10:31,863 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1485, Invalid=1485, Unknown=0, NotChecked=0, Total=2970 [2018-11-23 12:10:31,864 INFO L87 Difference]: Start difference. First operand 81 states and 83 transitions. Second operand 55 states. [2018-11-23 12:10:33,765 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:33,765 INFO L93 Difference]: Finished difference Result 129 states and 141 transitions. [2018-11-23 12:10:33,765 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 54 states. [2018-11-23 12:10:33,765 INFO L78 Accepts]: Start accepts. Automaton has 55 states. Word has length 77 [2018-11-23 12:10:33,765 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:33,766 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 55 states. [2018-11-23 12:10:33,767 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 54 states to 54 states and 127 transitions. [2018-11-23 12:10:33,767 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 55 states. [2018-11-23 12:10:33,768 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 54 states to 54 states and 127 transitions. [2018-11-23 12:10:33,769 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 54 states and 127 transitions. [2018-11-23 12:10:33,927 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 127 edges. 127 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:33,929 INFO L225 Difference]: With dead ends: 129 [2018-11-23 12:10:33,929 INFO L226 Difference]: Without dead ends: 106 [2018-11-23 12:10:33,931 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 130 GetRequests, 77 SyntacticMatches, 0 SemanticMatches, 53 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 100 ImplicationChecksByTransitivity, 1.4s TimeCoverageRelationStatistics Valid=1485, Invalid=1485, Unknown=0, NotChecked=0, Total=2970 [2018-11-23 12:10:33,931 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 106 states. [2018-11-23 12:10:34,185 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 106 to 82. [2018-11-23 12:10:34,185 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:34,185 INFO L82 GeneralOperation]: Start isEquivalent. First operand 106 states. Second operand 82 states. [2018-11-23 12:10:34,185 INFO L74 IsIncluded]: Start isIncluded. First operand 106 states. Second operand 82 states. [2018-11-23 12:10:34,185 INFO L87 Difference]: Start difference. First operand 106 states. Second operand 82 states. [2018-11-23 12:10:34,187 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:34,188 INFO L93 Difference]: Finished difference Result 106 states and 116 transitions. [2018-11-23 12:10:34,188 INFO L276 IsEmpty]: Start isEmpty. Operand 106 states and 116 transitions. [2018-11-23 12:10:34,188 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:34,188 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:34,189 INFO L74 IsIncluded]: Start isIncluded. First operand 82 states. Second operand 106 states. [2018-11-23 12:10:34,189 INFO L87 Difference]: Start difference. First operand 82 states. Second operand 106 states. [2018-11-23 12:10:34,191 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:34,191 INFO L93 Difference]: Finished difference Result 106 states and 116 transitions. [2018-11-23 12:10:34,191 INFO L276 IsEmpty]: Start isEmpty. Operand 106 states and 116 transitions. [2018-11-23 12:10:34,192 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:34,192 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:34,192 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:34,192 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:34,192 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 82 states. [2018-11-23 12:10:34,193 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 82 states to 82 states and 84 transitions. [2018-11-23 12:10:34,193 INFO L78 Accepts]: Start accepts. Automaton has 82 states and 84 transitions. Word has length 77 [2018-11-23 12:10:34,194 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:34,194 INFO L480 AbstractCegarLoop]: Abstraction has 82 states and 84 transitions. [2018-11-23 12:10:34,194 INFO L481 AbstractCegarLoop]: Interpolant automaton has 55 states. [2018-11-23 12:10:34,194 INFO L276 IsEmpty]: Start isEmpty. Operand 82 states and 84 transitions. [2018-11-23 12:10:34,195 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 79 [2018-11-23 12:10:34,195 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:34,195 INFO L402 BasicCegarLoop]: trace histogram [52, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:34,195 INFO L423 AbstractCegarLoop]: === Iteration 29 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:34,195 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:34,196 INFO L82 PathProgramCache]: Analyzing trace with hash -1942652791, now seen corresponding path program 26 times [2018-11-23 12:10:34,196 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:34,196 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:34,196 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:34,197 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:10:34,197 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:34,260 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:36,156 INFO L256 TraceCheckUtils]: 0: Hoare triple {12699#true} call ULTIMATE.init(); {12699#true} is VALID [2018-11-23 12:10:36,156 INFO L273 TraceCheckUtils]: 1: Hoare triple {12699#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {12699#true} is VALID [2018-11-23 12:10:36,156 INFO L273 TraceCheckUtils]: 2: Hoare triple {12699#true} assume true; {12699#true} is VALID [2018-11-23 12:10:36,156 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {12699#true} {12699#true} #60#return; {12699#true} is VALID [2018-11-23 12:10:36,157 INFO L256 TraceCheckUtils]: 4: Hoare triple {12699#true} call #t~ret4 := main(); {12699#true} is VALID [2018-11-23 12:10:36,157 INFO L273 TraceCheckUtils]: 5: Hoare triple {12699#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; {12701#(= main_~i~0 0)} is VALID [2018-11-23 12:10:36,158 INFO L273 TraceCheckUtils]: 6: Hoare triple {12701#(= 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; {12702#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:36,159 INFO L273 TraceCheckUtils]: 7: Hoare triple {12702#(<= 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; {12703#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:36,159 INFO L273 TraceCheckUtils]: 8: Hoare triple {12703#(<= 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; {12704#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:36,160 INFO L273 TraceCheckUtils]: 9: Hoare triple {12704#(<= 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; {12705#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:36,161 INFO L273 TraceCheckUtils]: 10: Hoare triple {12705#(<= 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; {12706#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:36,161 INFO L273 TraceCheckUtils]: 11: Hoare triple {12706#(<= 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; {12707#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:36,162 INFO L273 TraceCheckUtils]: 12: Hoare triple {12707#(<= 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; {12708#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:36,163 INFO L273 TraceCheckUtils]: 13: Hoare triple {12708#(<= 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; {12709#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:36,164 INFO L273 TraceCheckUtils]: 14: Hoare triple {12709#(<= 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; {12710#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:36,165 INFO L273 TraceCheckUtils]: 15: Hoare triple {12710#(<= 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; {12711#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:36,166 INFO L273 TraceCheckUtils]: 16: Hoare triple {12711#(<= 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; {12712#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:36,167 INFO L273 TraceCheckUtils]: 17: Hoare triple {12712#(<= 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; {12713#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:36,168 INFO L273 TraceCheckUtils]: 18: Hoare triple {12713#(<= 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; {12714#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:36,169 INFO L273 TraceCheckUtils]: 19: Hoare triple {12714#(<= 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; {12715#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:36,170 INFO L273 TraceCheckUtils]: 20: Hoare triple {12715#(<= 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; {12716#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:36,171 INFO L273 TraceCheckUtils]: 21: Hoare triple {12716#(<= 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; {12717#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:36,172 INFO L273 TraceCheckUtils]: 22: Hoare triple {12717#(<= 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; {12718#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:36,173 INFO L273 TraceCheckUtils]: 23: Hoare triple {12718#(<= 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; {12719#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:36,174 INFO L273 TraceCheckUtils]: 24: Hoare triple {12719#(<= 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; {12720#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:36,175 INFO L273 TraceCheckUtils]: 25: Hoare triple {12720#(<= 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; {12721#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:36,176 INFO L273 TraceCheckUtils]: 26: Hoare triple {12721#(<= 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; {12722#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:36,177 INFO L273 TraceCheckUtils]: 27: Hoare triple {12722#(<= 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; {12723#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:36,178 INFO L273 TraceCheckUtils]: 28: Hoare triple {12723#(<= 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; {12724#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:36,179 INFO L273 TraceCheckUtils]: 29: Hoare triple {12724#(<= 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; {12725#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:36,180 INFO L273 TraceCheckUtils]: 30: Hoare triple {12725#(<= 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; {12726#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:36,181 INFO L273 TraceCheckUtils]: 31: Hoare triple {12726#(<= 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; {12727#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:36,182 INFO L273 TraceCheckUtils]: 32: Hoare triple {12727#(<= 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; {12728#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:36,183 INFO L273 TraceCheckUtils]: 33: Hoare triple {12728#(<= 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; {12729#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:36,184 INFO L273 TraceCheckUtils]: 34: Hoare triple {12729#(<= 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; {12730#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:36,185 INFO L273 TraceCheckUtils]: 35: Hoare triple {12730#(<= 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; {12731#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:36,186 INFO L273 TraceCheckUtils]: 36: Hoare triple {12731#(<= 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; {12732#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:36,187 INFO L273 TraceCheckUtils]: 37: Hoare triple {12732#(<= 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; {12733#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:36,188 INFO L273 TraceCheckUtils]: 38: Hoare triple {12733#(<= 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; {12734#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:36,189 INFO L273 TraceCheckUtils]: 39: Hoare triple {12734#(<= 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; {12735#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:36,190 INFO L273 TraceCheckUtils]: 40: Hoare triple {12735#(<= 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; {12736#(<= main_~i~0 35)} is VALID [2018-11-23 12:10:36,191 INFO L273 TraceCheckUtils]: 41: Hoare triple {12736#(<= 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; {12737#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:36,192 INFO L273 TraceCheckUtils]: 42: Hoare triple {12737#(<= 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; {12738#(<= main_~i~0 37)} is VALID [2018-11-23 12:10:36,193 INFO L273 TraceCheckUtils]: 43: Hoare triple {12738#(<= 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; {12739#(<= main_~i~0 38)} is VALID [2018-11-23 12:10:36,194 INFO L273 TraceCheckUtils]: 44: Hoare triple {12739#(<= 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; {12740#(<= main_~i~0 39)} is VALID [2018-11-23 12:10:36,195 INFO L273 TraceCheckUtils]: 45: Hoare triple {12740#(<= 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; {12741#(<= main_~i~0 40)} is VALID [2018-11-23 12:10:36,196 INFO L273 TraceCheckUtils]: 46: Hoare triple {12741#(<= 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; {12742#(<= main_~i~0 41)} is VALID [2018-11-23 12:10:36,197 INFO L273 TraceCheckUtils]: 47: Hoare triple {12742#(<= 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; {12743#(<= main_~i~0 42)} is VALID [2018-11-23 12:10:36,198 INFO L273 TraceCheckUtils]: 48: Hoare triple {12743#(<= 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; {12744#(<= main_~i~0 43)} is VALID [2018-11-23 12:10:36,200 INFO L273 TraceCheckUtils]: 49: Hoare triple {12744#(<= 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; {12745#(<= main_~i~0 44)} is VALID [2018-11-23 12:10:36,201 INFO L273 TraceCheckUtils]: 50: Hoare triple {12745#(<= 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; {12746#(<= main_~i~0 45)} is VALID [2018-11-23 12:10:36,202 INFO L273 TraceCheckUtils]: 51: Hoare triple {12746#(<= 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; {12747#(<= main_~i~0 46)} is VALID [2018-11-23 12:10:36,203 INFO L273 TraceCheckUtils]: 52: Hoare triple {12747#(<= 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; {12748#(<= main_~i~0 47)} is VALID [2018-11-23 12:10:36,204 INFO L273 TraceCheckUtils]: 53: Hoare triple {12748#(<= 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; {12749#(<= main_~i~0 48)} is VALID [2018-11-23 12:10:36,205 INFO L273 TraceCheckUtils]: 54: Hoare triple {12749#(<= 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; {12750#(<= main_~i~0 49)} is VALID [2018-11-23 12:10:36,206 INFO L273 TraceCheckUtils]: 55: Hoare triple {12750#(<= 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; {12751#(<= main_~i~0 50)} is VALID [2018-11-23 12:10:36,207 INFO L273 TraceCheckUtils]: 56: Hoare triple {12751#(<= 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; {12752#(<= main_~i~0 51)} is VALID [2018-11-23 12:10:36,208 INFO L273 TraceCheckUtils]: 57: Hoare triple {12752#(<= 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; {12753#(<= main_~i~0 52)} is VALID [2018-11-23 12:10:36,208 INFO L273 TraceCheckUtils]: 58: Hoare triple {12753#(<= main_~i~0 52)} assume !(~i~0 < 100000); {12700#false} is VALID [2018-11-23 12:10:36,208 INFO L273 TraceCheckUtils]: 59: Hoare triple {12700#false} ~i~0 := 1; {12700#false} is VALID [2018-11-23 12:10:36,209 INFO L273 TraceCheckUtils]: 60: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,209 INFO L273 TraceCheckUtils]: 61: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,209 INFO L273 TraceCheckUtils]: 62: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,209 INFO L273 TraceCheckUtils]: 63: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,209 INFO L273 TraceCheckUtils]: 64: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,210 INFO L273 TraceCheckUtils]: 65: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,210 INFO L273 TraceCheckUtils]: 66: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,210 INFO L273 TraceCheckUtils]: 67: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,210 INFO L273 TraceCheckUtils]: 68: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,210 INFO L273 TraceCheckUtils]: 69: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,211 INFO L273 TraceCheckUtils]: 70: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,211 INFO L273 TraceCheckUtils]: 71: Hoare triple {12700#false} assume !(~i~0 < 100000); {12700#false} is VALID [2018-11-23 12:10:36,211 INFO L273 TraceCheckUtils]: 72: Hoare triple {12700#false} ~i~0 := 1;~j~0 := 0; {12700#false} is VALID [2018-11-23 12:10:36,211 INFO L273 TraceCheckUtils]: 73: Hoare triple {12700#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 + 7 * ~j~0), 4); {12700#false} is VALID [2018-11-23 12:10:36,211 INFO L256 TraceCheckUtils]: 74: Hoare triple {12700#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {12700#false} is VALID [2018-11-23 12:10:36,211 INFO L273 TraceCheckUtils]: 75: Hoare triple {12700#false} ~cond := #in~cond; {12700#false} is VALID [2018-11-23 12:10:36,212 INFO L273 TraceCheckUtils]: 76: Hoare triple {12700#false} assume 0 == ~cond; {12700#false} is VALID [2018-11-23 12:10:36,212 INFO L273 TraceCheckUtils]: 77: Hoare triple {12700#false} assume !false; {12700#false} is VALID [2018-11-23 12:10:36,216 INFO L134 CoverageAnalysis]: Checked inductivity of 1444 backedges. 0 proven. 1378 refuted. 0 times theorem prover too weak. 66 trivial. 0 not checked. [2018-11-23 12:10:36,216 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:36,216 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:10:36,225 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:10:36,297 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:10:36,297 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:36,322 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:36,324 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:36,619 INFO L256 TraceCheckUtils]: 0: Hoare triple {12699#true} call ULTIMATE.init(); {12699#true} is VALID [2018-11-23 12:10:36,620 INFO L273 TraceCheckUtils]: 1: Hoare triple {12699#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {12699#true} is VALID [2018-11-23 12:10:36,620 INFO L273 TraceCheckUtils]: 2: Hoare triple {12699#true} assume true; {12699#true} is VALID [2018-11-23 12:10:36,620 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {12699#true} {12699#true} #60#return; {12699#true} is VALID [2018-11-23 12:10:36,620 INFO L256 TraceCheckUtils]: 4: Hoare triple {12699#true} call #t~ret4 := main(); {12699#true} is VALID [2018-11-23 12:10:36,621 INFO L273 TraceCheckUtils]: 5: Hoare triple {12699#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; {12772#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:36,622 INFO L273 TraceCheckUtils]: 6: Hoare triple {12772#(<= 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; {12702#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:36,623 INFO L273 TraceCheckUtils]: 7: Hoare triple {12702#(<= 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; {12703#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:36,623 INFO L273 TraceCheckUtils]: 8: Hoare triple {12703#(<= 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; {12704#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:36,624 INFO L273 TraceCheckUtils]: 9: Hoare triple {12704#(<= 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; {12705#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:36,625 INFO L273 TraceCheckUtils]: 10: Hoare triple {12705#(<= 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; {12706#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:36,626 INFO L273 TraceCheckUtils]: 11: Hoare triple {12706#(<= 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; {12707#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:36,627 INFO L273 TraceCheckUtils]: 12: Hoare triple {12707#(<= 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; {12708#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:36,628 INFO L273 TraceCheckUtils]: 13: Hoare triple {12708#(<= 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; {12709#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:36,629 INFO L273 TraceCheckUtils]: 14: Hoare triple {12709#(<= 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; {12710#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:36,630 INFO L273 TraceCheckUtils]: 15: Hoare triple {12710#(<= 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; {12711#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:36,631 INFO L273 TraceCheckUtils]: 16: Hoare triple {12711#(<= 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; {12712#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:36,632 INFO L273 TraceCheckUtils]: 17: Hoare triple {12712#(<= 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; {12713#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:36,633 INFO L273 TraceCheckUtils]: 18: Hoare triple {12713#(<= 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; {12714#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:36,634 INFO L273 TraceCheckUtils]: 19: Hoare triple {12714#(<= 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; {12715#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:36,635 INFO L273 TraceCheckUtils]: 20: Hoare triple {12715#(<= 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; {12716#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:36,636 INFO L273 TraceCheckUtils]: 21: Hoare triple {12716#(<= 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; {12717#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:36,637 INFO L273 TraceCheckUtils]: 22: Hoare triple {12717#(<= 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; {12718#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:36,638 INFO L273 TraceCheckUtils]: 23: Hoare triple {12718#(<= 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; {12719#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:36,639 INFO L273 TraceCheckUtils]: 24: Hoare triple {12719#(<= 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; {12720#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:36,640 INFO L273 TraceCheckUtils]: 25: Hoare triple {12720#(<= 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; {12721#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:36,641 INFO L273 TraceCheckUtils]: 26: Hoare triple {12721#(<= 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; {12722#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:36,642 INFO L273 TraceCheckUtils]: 27: Hoare triple {12722#(<= 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; {12723#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:36,643 INFO L273 TraceCheckUtils]: 28: Hoare triple {12723#(<= 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; {12724#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:36,644 INFO L273 TraceCheckUtils]: 29: Hoare triple {12724#(<= 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; {12725#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:36,645 INFO L273 TraceCheckUtils]: 30: Hoare triple {12725#(<= 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; {12726#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:36,646 INFO L273 TraceCheckUtils]: 31: Hoare triple {12726#(<= 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; {12727#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:36,647 INFO L273 TraceCheckUtils]: 32: Hoare triple {12727#(<= 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; {12728#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:36,648 INFO L273 TraceCheckUtils]: 33: Hoare triple {12728#(<= 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; {12729#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:36,649 INFO L273 TraceCheckUtils]: 34: Hoare triple {12729#(<= 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; {12730#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:36,650 INFO L273 TraceCheckUtils]: 35: Hoare triple {12730#(<= 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; {12731#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:36,651 INFO L273 TraceCheckUtils]: 36: Hoare triple {12731#(<= 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; {12732#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:36,652 INFO L273 TraceCheckUtils]: 37: Hoare triple {12732#(<= 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; {12733#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:36,653 INFO L273 TraceCheckUtils]: 38: Hoare triple {12733#(<= 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; {12734#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:36,654 INFO L273 TraceCheckUtils]: 39: Hoare triple {12734#(<= 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; {12735#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:36,655 INFO L273 TraceCheckUtils]: 40: Hoare triple {12735#(<= 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; {12736#(<= main_~i~0 35)} is VALID [2018-11-23 12:10:36,656 INFO L273 TraceCheckUtils]: 41: Hoare triple {12736#(<= 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; {12737#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:36,657 INFO L273 TraceCheckUtils]: 42: Hoare triple {12737#(<= 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; {12738#(<= main_~i~0 37)} is VALID [2018-11-23 12:10:36,658 INFO L273 TraceCheckUtils]: 43: Hoare triple {12738#(<= 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; {12739#(<= main_~i~0 38)} is VALID [2018-11-23 12:10:36,659 INFO L273 TraceCheckUtils]: 44: Hoare triple {12739#(<= 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; {12740#(<= main_~i~0 39)} is VALID [2018-11-23 12:10:36,660 INFO L273 TraceCheckUtils]: 45: Hoare triple {12740#(<= 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; {12741#(<= main_~i~0 40)} is VALID [2018-11-23 12:10:36,661 INFO L273 TraceCheckUtils]: 46: Hoare triple {12741#(<= 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; {12742#(<= main_~i~0 41)} is VALID [2018-11-23 12:10:36,662 INFO L273 TraceCheckUtils]: 47: Hoare triple {12742#(<= 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; {12743#(<= main_~i~0 42)} is VALID [2018-11-23 12:10:36,663 INFO L273 TraceCheckUtils]: 48: Hoare triple {12743#(<= 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; {12744#(<= main_~i~0 43)} is VALID [2018-11-23 12:10:36,664 INFO L273 TraceCheckUtils]: 49: Hoare triple {12744#(<= 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; {12745#(<= main_~i~0 44)} is VALID [2018-11-23 12:10:36,665 INFO L273 TraceCheckUtils]: 50: Hoare triple {12745#(<= 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; {12746#(<= main_~i~0 45)} is VALID [2018-11-23 12:10:36,666 INFO L273 TraceCheckUtils]: 51: Hoare triple {12746#(<= 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; {12747#(<= main_~i~0 46)} is VALID [2018-11-23 12:10:36,667 INFO L273 TraceCheckUtils]: 52: Hoare triple {12747#(<= 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; {12748#(<= main_~i~0 47)} is VALID [2018-11-23 12:10:36,668 INFO L273 TraceCheckUtils]: 53: Hoare triple {12748#(<= 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; {12749#(<= main_~i~0 48)} is VALID [2018-11-23 12:10:36,669 INFO L273 TraceCheckUtils]: 54: Hoare triple {12749#(<= 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; {12750#(<= main_~i~0 49)} is VALID [2018-11-23 12:10:36,671 INFO L273 TraceCheckUtils]: 55: Hoare triple {12750#(<= 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; {12751#(<= main_~i~0 50)} is VALID [2018-11-23 12:10:36,672 INFO L273 TraceCheckUtils]: 56: Hoare triple {12751#(<= 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; {12752#(<= main_~i~0 51)} is VALID [2018-11-23 12:10:36,673 INFO L273 TraceCheckUtils]: 57: Hoare triple {12752#(<= 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; {12753#(<= main_~i~0 52)} is VALID [2018-11-23 12:10:36,673 INFO L273 TraceCheckUtils]: 58: Hoare triple {12753#(<= main_~i~0 52)} assume !(~i~0 < 100000); {12700#false} is VALID [2018-11-23 12:10:36,673 INFO L273 TraceCheckUtils]: 59: Hoare triple {12700#false} ~i~0 := 1; {12700#false} is VALID [2018-11-23 12:10:36,674 INFO L273 TraceCheckUtils]: 60: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,674 INFO L273 TraceCheckUtils]: 61: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,674 INFO L273 TraceCheckUtils]: 62: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,674 INFO L273 TraceCheckUtils]: 63: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,674 INFO L273 TraceCheckUtils]: 64: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,675 INFO L273 TraceCheckUtils]: 65: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,675 INFO L273 TraceCheckUtils]: 66: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,675 INFO L273 TraceCheckUtils]: 67: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,675 INFO L273 TraceCheckUtils]: 68: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,675 INFO L273 TraceCheckUtils]: 69: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,676 INFO L273 TraceCheckUtils]: 70: Hoare triple {12700#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {12700#false} is VALID [2018-11-23 12:10:36,676 INFO L273 TraceCheckUtils]: 71: Hoare triple {12700#false} assume !(~i~0 < 100000); {12700#false} is VALID [2018-11-23 12:10:36,676 INFO L273 TraceCheckUtils]: 72: Hoare triple {12700#false} ~i~0 := 1;~j~0 := 0; {12700#false} is VALID [2018-11-23 12:10:36,676 INFO L273 TraceCheckUtils]: 73: Hoare triple {12700#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 + 7 * ~j~0), 4); {12700#false} is VALID [2018-11-23 12:10:36,676 INFO L256 TraceCheckUtils]: 74: Hoare triple {12700#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {12700#false} is VALID [2018-11-23 12:10:36,676 INFO L273 TraceCheckUtils]: 75: Hoare triple {12700#false} ~cond := #in~cond; {12700#false} is VALID [2018-11-23 12:10:36,676 INFO L273 TraceCheckUtils]: 76: Hoare triple {12700#false} assume 0 == ~cond; {12700#false} is VALID [2018-11-23 12:10:36,677 INFO L273 TraceCheckUtils]: 77: Hoare triple {12700#false} assume !false; {12700#false} is VALID [2018-11-23 12:10:36,681 INFO L134 CoverageAnalysis]: Checked inductivity of 1444 backedges. 0 proven. 1378 refuted. 0 times theorem prover too weak. 66 trivial. 0 not checked. [2018-11-23 12:10:36,700 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:36,700 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [55, 55] total 56 [2018-11-23 12:10:36,701 INFO L78 Accepts]: Start accepts. Automaton has 56 states. Word has length 78 [2018-11-23 12:10:36,701 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:36,701 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 56 states. [2018-11-23 12:10:36,752 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:10:36,752 INFO L459 AbstractCegarLoop]: Interpolant automaton has 56 states [2018-11-23 12:10:36,753 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 56 interpolants. [2018-11-23 12:10:36,754 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1540, Invalid=1540, Unknown=0, NotChecked=0, Total=3080 [2018-11-23 12:10:36,755 INFO L87 Difference]: Start difference. First operand 82 states and 84 transitions. Second operand 56 states. [2018-11-23 12:10:39,264 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:39,264 INFO L93 Difference]: Finished difference Result 130 states and 142 transitions. [2018-11-23 12:10:39,265 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 55 states. [2018-11-23 12:10:39,265 INFO L78 Accepts]: Start accepts. Automaton has 56 states. Word has length 78 [2018-11-23 12:10:39,265 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:39,265 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 56 states. [2018-11-23 12:10:39,267 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 55 states to 55 states and 128 transitions. [2018-11-23 12:10:39,267 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 56 states. [2018-11-23 12:10:39,269 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 55 states to 55 states and 128 transitions. [2018-11-23 12:10:39,269 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 55 states and 128 transitions. [2018-11-23 12:10:39,428 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 128 edges. 128 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:39,431 INFO L225 Difference]: With dead ends: 130 [2018-11-23 12:10:39,431 INFO L226 Difference]: Without dead ends: 107 [2018-11-23 12:10:39,432 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 132 GetRequests, 78 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:10:39,433 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 107 states. [2018-11-23 12:10:39,496 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 107 to 83. [2018-11-23 12:10:39,496 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:39,497 INFO L82 GeneralOperation]: Start isEquivalent. First operand 107 states. Second operand 83 states. [2018-11-23 12:10:39,497 INFO L74 IsIncluded]: Start isIncluded. First operand 107 states. Second operand 83 states. [2018-11-23 12:10:39,497 INFO L87 Difference]: Start difference. First operand 107 states. Second operand 83 states. [2018-11-23 12:10:39,499 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:39,500 INFO L93 Difference]: Finished difference Result 107 states and 117 transitions. [2018-11-23 12:10:39,500 INFO L276 IsEmpty]: Start isEmpty. Operand 107 states and 117 transitions. [2018-11-23 12:10:39,500 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:39,500 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:39,500 INFO L74 IsIncluded]: Start isIncluded. First operand 83 states. Second operand 107 states. [2018-11-23 12:10:39,500 INFO L87 Difference]: Start difference. First operand 83 states. Second operand 107 states. [2018-11-23 12:10:39,502 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:39,502 INFO L93 Difference]: Finished difference Result 107 states and 117 transitions. [2018-11-23 12:10:39,502 INFO L276 IsEmpty]: Start isEmpty. Operand 107 states and 117 transitions. [2018-11-23 12:10:39,503 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:39,503 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:39,503 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:39,503 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:39,503 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 83 states. [2018-11-23 12:10:39,504 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 83 states to 83 states and 85 transitions. [2018-11-23 12:10:39,505 INFO L78 Accepts]: Start accepts. Automaton has 83 states and 85 transitions. Word has length 78 [2018-11-23 12:10:39,505 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:39,505 INFO L480 AbstractCegarLoop]: Abstraction has 83 states and 85 transitions. [2018-11-23 12:10:39,505 INFO L481 AbstractCegarLoop]: Interpolant automaton has 56 states. [2018-11-23 12:10:39,505 INFO L276 IsEmpty]: Start isEmpty. Operand 83 states and 85 transitions. [2018-11-23 12:10:39,506 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 80 [2018-11-23 12:10:39,506 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:39,506 INFO L402 BasicCegarLoop]: trace histogram [53, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:39,506 INFO L423 AbstractCegarLoop]: === Iteration 30 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:39,506 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:39,507 INFO L82 PathProgramCache]: Analyzing trace with hash -324595739, now seen corresponding path program 27 times [2018-11-23 12:10:39,507 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:39,507 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:39,507 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:39,507 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:39,507 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:39,571 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:40,893 INFO L256 TraceCheckUtils]: 0: Hoare triple {13592#true} call ULTIMATE.init(); {13592#true} is VALID [2018-11-23 12:10:40,893 INFO L273 TraceCheckUtils]: 1: Hoare triple {13592#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {13592#true} is VALID [2018-11-23 12:10:40,893 INFO L273 TraceCheckUtils]: 2: Hoare triple {13592#true} assume true; {13592#true} is VALID [2018-11-23 12:10:40,893 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {13592#true} {13592#true} #60#return; {13592#true} is VALID [2018-11-23 12:10:40,894 INFO L256 TraceCheckUtils]: 4: Hoare triple {13592#true} call #t~ret4 := main(); {13592#true} is VALID [2018-11-23 12:10:40,894 INFO L273 TraceCheckUtils]: 5: Hoare triple {13592#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; {13594#(= main_~i~0 0)} is VALID [2018-11-23 12:10:40,895 INFO L273 TraceCheckUtils]: 6: Hoare triple {13594#(= 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; {13595#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:40,896 INFO L273 TraceCheckUtils]: 7: Hoare triple {13595#(<= 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; {13596#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:40,896 INFO L273 TraceCheckUtils]: 8: Hoare triple {13596#(<= 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; {13597#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:40,897 INFO L273 TraceCheckUtils]: 9: Hoare triple {13597#(<= 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; {13598#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:40,898 INFO L273 TraceCheckUtils]: 10: Hoare triple {13598#(<= 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; {13599#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:40,898 INFO L273 TraceCheckUtils]: 11: Hoare triple {13599#(<= 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; {13600#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:40,899 INFO L273 TraceCheckUtils]: 12: Hoare triple {13600#(<= 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; {13601#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:40,900 INFO L273 TraceCheckUtils]: 13: Hoare triple {13601#(<= 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; {13602#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:40,901 INFO L273 TraceCheckUtils]: 14: Hoare triple {13602#(<= 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; {13603#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:40,902 INFO L273 TraceCheckUtils]: 15: Hoare triple {13603#(<= 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; {13604#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:40,903 INFO L273 TraceCheckUtils]: 16: Hoare triple {13604#(<= 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; {13605#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:40,904 INFO L273 TraceCheckUtils]: 17: Hoare triple {13605#(<= 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; {13606#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:40,905 INFO L273 TraceCheckUtils]: 18: Hoare triple {13606#(<= 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; {13607#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:40,906 INFO L273 TraceCheckUtils]: 19: Hoare triple {13607#(<= 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; {13608#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:40,907 INFO L273 TraceCheckUtils]: 20: Hoare triple {13608#(<= 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; {13609#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:40,908 INFO L273 TraceCheckUtils]: 21: Hoare triple {13609#(<= 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; {13610#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:40,909 INFO L273 TraceCheckUtils]: 22: Hoare triple {13610#(<= 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; {13611#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:40,910 INFO L273 TraceCheckUtils]: 23: Hoare triple {13611#(<= 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; {13612#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:40,912 INFO L273 TraceCheckUtils]: 24: Hoare triple {13612#(<= 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; {13613#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:40,912 INFO L273 TraceCheckUtils]: 25: Hoare triple {13613#(<= 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; {13614#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:40,914 INFO L273 TraceCheckUtils]: 26: Hoare triple {13614#(<= 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; {13615#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:40,915 INFO L273 TraceCheckUtils]: 27: Hoare triple {13615#(<= 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; {13616#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:40,916 INFO L273 TraceCheckUtils]: 28: Hoare triple {13616#(<= 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; {13617#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:40,917 INFO L273 TraceCheckUtils]: 29: Hoare triple {13617#(<= 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; {13618#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:40,918 INFO L273 TraceCheckUtils]: 30: Hoare triple {13618#(<= 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; {13619#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:40,919 INFO L273 TraceCheckUtils]: 31: Hoare triple {13619#(<= 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; {13620#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:40,920 INFO L273 TraceCheckUtils]: 32: Hoare triple {13620#(<= 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; {13621#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:40,921 INFO L273 TraceCheckUtils]: 33: Hoare triple {13621#(<= 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; {13622#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:40,922 INFO L273 TraceCheckUtils]: 34: Hoare triple {13622#(<= 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; {13623#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:40,923 INFO L273 TraceCheckUtils]: 35: Hoare triple {13623#(<= 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; {13624#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:40,924 INFO L273 TraceCheckUtils]: 36: Hoare triple {13624#(<= 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; {13625#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:40,925 INFO L273 TraceCheckUtils]: 37: Hoare triple {13625#(<= 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; {13626#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:40,926 INFO L273 TraceCheckUtils]: 38: Hoare triple {13626#(<= 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; {13627#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:40,927 INFO L273 TraceCheckUtils]: 39: Hoare triple {13627#(<= 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; {13628#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:40,928 INFO L273 TraceCheckUtils]: 40: Hoare triple {13628#(<= 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; {13629#(<= main_~i~0 35)} is VALID [2018-11-23 12:10:40,929 INFO L273 TraceCheckUtils]: 41: Hoare triple {13629#(<= 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; {13630#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:40,930 INFO L273 TraceCheckUtils]: 42: Hoare triple {13630#(<= 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; {13631#(<= main_~i~0 37)} is VALID [2018-11-23 12:10:40,931 INFO L273 TraceCheckUtils]: 43: Hoare triple {13631#(<= 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; {13632#(<= main_~i~0 38)} is VALID [2018-11-23 12:10:40,932 INFO L273 TraceCheckUtils]: 44: Hoare triple {13632#(<= 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; {13633#(<= main_~i~0 39)} is VALID [2018-11-23 12:10:40,933 INFO L273 TraceCheckUtils]: 45: Hoare triple {13633#(<= 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; {13634#(<= main_~i~0 40)} is VALID [2018-11-23 12:10:40,934 INFO L273 TraceCheckUtils]: 46: Hoare triple {13634#(<= 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; {13635#(<= main_~i~0 41)} is VALID [2018-11-23 12:10:40,935 INFO L273 TraceCheckUtils]: 47: Hoare triple {13635#(<= 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; {13636#(<= main_~i~0 42)} is VALID [2018-11-23 12:10:40,936 INFO L273 TraceCheckUtils]: 48: Hoare triple {13636#(<= 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; {13637#(<= main_~i~0 43)} is VALID [2018-11-23 12:10:40,937 INFO L273 TraceCheckUtils]: 49: Hoare triple {13637#(<= 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; {13638#(<= main_~i~0 44)} is VALID [2018-11-23 12:10:40,938 INFO L273 TraceCheckUtils]: 50: Hoare triple {13638#(<= 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; {13639#(<= main_~i~0 45)} is VALID [2018-11-23 12:10:40,939 INFO L273 TraceCheckUtils]: 51: Hoare triple {13639#(<= 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; {13640#(<= main_~i~0 46)} is VALID [2018-11-23 12:10:40,940 INFO L273 TraceCheckUtils]: 52: Hoare triple {13640#(<= 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; {13641#(<= main_~i~0 47)} is VALID [2018-11-23 12:10:40,941 INFO L273 TraceCheckUtils]: 53: Hoare triple {13641#(<= 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; {13642#(<= main_~i~0 48)} is VALID [2018-11-23 12:10:40,942 INFO L273 TraceCheckUtils]: 54: Hoare triple {13642#(<= 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; {13643#(<= main_~i~0 49)} is VALID [2018-11-23 12:10:40,943 INFO L273 TraceCheckUtils]: 55: Hoare triple {13643#(<= 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; {13644#(<= main_~i~0 50)} is VALID [2018-11-23 12:10:40,944 INFO L273 TraceCheckUtils]: 56: Hoare triple {13644#(<= 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; {13645#(<= main_~i~0 51)} is VALID [2018-11-23 12:10:40,945 INFO L273 TraceCheckUtils]: 57: Hoare triple {13645#(<= 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; {13646#(<= main_~i~0 52)} is VALID [2018-11-23 12:10:40,946 INFO L273 TraceCheckUtils]: 58: Hoare triple {13646#(<= 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; {13647#(<= main_~i~0 53)} is VALID [2018-11-23 12:10:40,947 INFO L273 TraceCheckUtils]: 59: Hoare triple {13647#(<= main_~i~0 53)} assume !(~i~0 < 100000); {13593#false} is VALID [2018-11-23 12:10:40,947 INFO L273 TraceCheckUtils]: 60: Hoare triple {13593#false} ~i~0 := 1; {13593#false} is VALID [2018-11-23 12:10:40,947 INFO L273 TraceCheckUtils]: 61: Hoare triple {13593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13593#false} is VALID [2018-11-23 12:10:40,947 INFO L273 TraceCheckUtils]: 62: Hoare triple {13593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13593#false} is VALID [2018-11-23 12:10:40,947 INFO L273 TraceCheckUtils]: 63: Hoare triple {13593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13593#false} is VALID [2018-11-23 12:10:40,948 INFO L273 TraceCheckUtils]: 64: Hoare triple {13593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13593#false} is VALID [2018-11-23 12:10:40,948 INFO L273 TraceCheckUtils]: 65: Hoare triple {13593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13593#false} is VALID [2018-11-23 12:10:40,948 INFO L273 TraceCheckUtils]: 66: Hoare triple {13593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13593#false} is VALID [2018-11-23 12:10:40,948 INFO L273 TraceCheckUtils]: 67: Hoare triple {13593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13593#false} is VALID [2018-11-23 12:10:40,948 INFO L273 TraceCheckUtils]: 68: Hoare triple {13593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13593#false} is VALID [2018-11-23 12:10:40,949 INFO L273 TraceCheckUtils]: 69: Hoare triple {13593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13593#false} is VALID [2018-11-23 12:10:40,949 INFO L273 TraceCheckUtils]: 70: Hoare triple {13593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13593#false} is VALID [2018-11-23 12:10:40,949 INFO L273 TraceCheckUtils]: 71: Hoare triple {13593#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13593#false} is VALID [2018-11-23 12:10:40,949 INFO L273 TraceCheckUtils]: 72: Hoare triple {13593#false} assume !(~i~0 < 100000); {13593#false} is VALID [2018-11-23 12:10:40,949 INFO L273 TraceCheckUtils]: 73: Hoare triple {13593#false} ~i~0 := 1;~j~0 := 0; {13593#false} is VALID [2018-11-23 12:10:40,950 INFO L273 TraceCheckUtils]: 74: Hoare triple {13593#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 + 7 * ~j~0), 4); {13593#false} is VALID [2018-11-23 12:10:40,950 INFO L256 TraceCheckUtils]: 75: Hoare triple {13593#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {13593#false} is VALID [2018-11-23 12:10:40,950 INFO L273 TraceCheckUtils]: 76: Hoare triple {13593#false} ~cond := #in~cond; {13593#false} is VALID [2018-11-23 12:10:40,950 INFO L273 TraceCheckUtils]: 77: Hoare triple {13593#false} assume 0 == ~cond; {13593#false} is VALID [2018-11-23 12:10:40,950 INFO L273 TraceCheckUtils]: 78: Hoare triple {13593#false} assume !false; {13593#false} is VALID [2018-11-23 12:10:40,955 INFO L134 CoverageAnalysis]: Checked inductivity of 1497 backedges. 0 proven. 1431 refuted. 0 times theorem prover too weak. 66 trivial. 0 not checked. [2018-11-23 12:10:40,956 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:40,956 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:10:40,967 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:10:43,095 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 7 check-sat command(s) [2018-11-23 12:10:43,095 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:43,118 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:43,120 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:43,397 INFO L256 TraceCheckUtils]: 0: Hoare triple {13592#true} call ULTIMATE.init(); {13592#true} is VALID [2018-11-23 12:10:43,397 INFO L273 TraceCheckUtils]: 1: Hoare triple {13592#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {13592#true} is VALID [2018-11-23 12:10:43,397 INFO L273 TraceCheckUtils]: 2: Hoare triple {13592#true} assume true; {13592#true} is VALID [2018-11-23 12:10:43,398 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {13592#true} {13592#true} #60#return; {13592#true} is VALID [2018-11-23 12:10:43,398 INFO L256 TraceCheckUtils]: 4: Hoare triple {13592#true} call #t~ret4 := main(); {13592#true} is VALID [2018-11-23 12:10:43,398 INFO L273 TraceCheckUtils]: 5: Hoare triple {13592#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; {13592#true} is VALID [2018-11-23 12:10:43,398 INFO L273 TraceCheckUtils]: 6: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,398 INFO L273 TraceCheckUtils]: 7: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,399 INFO L273 TraceCheckUtils]: 8: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,399 INFO L273 TraceCheckUtils]: 9: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,399 INFO L273 TraceCheckUtils]: 10: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,399 INFO L273 TraceCheckUtils]: 11: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,399 INFO L273 TraceCheckUtils]: 12: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,399 INFO L273 TraceCheckUtils]: 13: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,399 INFO L273 TraceCheckUtils]: 14: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,399 INFO L273 TraceCheckUtils]: 15: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,400 INFO L273 TraceCheckUtils]: 16: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,400 INFO L273 TraceCheckUtils]: 17: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,400 INFO L273 TraceCheckUtils]: 18: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,400 INFO L273 TraceCheckUtils]: 19: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,400 INFO L273 TraceCheckUtils]: 20: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,400 INFO L273 TraceCheckUtils]: 21: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,400 INFO L273 TraceCheckUtils]: 22: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,400 INFO L273 TraceCheckUtils]: 23: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,400 INFO L273 TraceCheckUtils]: 24: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,401 INFO L273 TraceCheckUtils]: 25: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,401 INFO L273 TraceCheckUtils]: 26: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,401 INFO L273 TraceCheckUtils]: 27: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,401 INFO L273 TraceCheckUtils]: 28: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,401 INFO L273 TraceCheckUtils]: 29: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,401 INFO L273 TraceCheckUtils]: 30: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,401 INFO L273 TraceCheckUtils]: 31: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,401 INFO L273 TraceCheckUtils]: 32: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,402 INFO L273 TraceCheckUtils]: 33: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,402 INFO L273 TraceCheckUtils]: 34: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,402 INFO L273 TraceCheckUtils]: 35: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,402 INFO L273 TraceCheckUtils]: 36: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,402 INFO L273 TraceCheckUtils]: 37: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,402 INFO L273 TraceCheckUtils]: 38: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,402 INFO L273 TraceCheckUtils]: 39: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,402 INFO L273 TraceCheckUtils]: 40: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,402 INFO L273 TraceCheckUtils]: 41: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,403 INFO L273 TraceCheckUtils]: 42: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,403 INFO L273 TraceCheckUtils]: 43: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,403 INFO L273 TraceCheckUtils]: 44: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,403 INFO L273 TraceCheckUtils]: 45: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,403 INFO L273 TraceCheckUtils]: 46: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,403 INFO L273 TraceCheckUtils]: 47: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,403 INFO L273 TraceCheckUtils]: 48: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,403 INFO L273 TraceCheckUtils]: 49: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,403 INFO L273 TraceCheckUtils]: 50: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,404 INFO L273 TraceCheckUtils]: 51: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,404 INFO L273 TraceCheckUtils]: 52: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,404 INFO L273 TraceCheckUtils]: 53: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,404 INFO L273 TraceCheckUtils]: 54: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,404 INFO L273 TraceCheckUtils]: 55: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,404 INFO L273 TraceCheckUtils]: 56: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,404 INFO L273 TraceCheckUtils]: 57: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,404 INFO L273 TraceCheckUtils]: 58: Hoare triple {13592#true} assume !!(~i~0 < 100000);assume -2147483648 <= #t~nondet0 && #t~nondet0 <= 2147483647;call write~int(#t~nondet0, ~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);havoc #t~nondet0;~i~0 := 1 + ~i~0; {13592#true} is VALID [2018-11-23 12:10:43,405 INFO L273 TraceCheckUtils]: 59: Hoare triple {13592#true} assume !(~i~0 < 100000); {13592#true} is VALID [2018-11-23 12:10:43,405 INFO L273 TraceCheckUtils]: 60: Hoare triple {13592#true} ~i~0 := 1; {13595#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:43,406 INFO L273 TraceCheckUtils]: 61: Hoare triple {13595#(<= 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13602#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:43,406 INFO L273 TraceCheckUtils]: 62: Hoare triple {13602#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13609#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:43,407 INFO L273 TraceCheckUtils]: 63: Hoare triple {13609#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13616#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:43,408 INFO L273 TraceCheckUtils]: 64: Hoare triple {13616#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13623#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:43,409 INFO L273 TraceCheckUtils]: 65: Hoare triple {13623#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13630#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:43,410 INFO L273 TraceCheckUtils]: 66: Hoare triple {13630#(<= main_~i~0 36)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13637#(<= main_~i~0 43)} is VALID [2018-11-23 12:10:43,411 INFO L273 TraceCheckUtils]: 67: Hoare triple {13637#(<= main_~i~0 43)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13644#(<= main_~i~0 50)} is VALID [2018-11-23 12:10:43,412 INFO L273 TraceCheckUtils]: 68: Hoare triple {13644#(<= main_~i~0 50)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13855#(<= main_~i~0 57)} is VALID [2018-11-23 12:10:43,413 INFO L273 TraceCheckUtils]: 69: Hoare triple {13855#(<= main_~i~0 57)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13859#(<= main_~i~0 64)} is VALID [2018-11-23 12:10:43,414 INFO L273 TraceCheckUtils]: 70: Hoare triple {13859#(<= 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 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13863#(<= main_~i~0 71)} is VALID [2018-11-23 12:10:43,415 INFO L273 TraceCheckUtils]: 71: Hoare triple {13863#(<= main_~i~0 71)} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {13867#(<= main_~i~0 78)} is VALID [2018-11-23 12:10:43,416 INFO L273 TraceCheckUtils]: 72: Hoare triple {13867#(<= main_~i~0 78)} assume !(~i~0 < 100000); {13593#false} is VALID [2018-11-23 12:10:43,416 INFO L273 TraceCheckUtils]: 73: Hoare triple {13593#false} ~i~0 := 1;~j~0 := 0; {13593#false} is VALID [2018-11-23 12:10:43,416 INFO L273 TraceCheckUtils]: 74: Hoare triple {13593#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 + 7 * ~j~0), 4); {13593#false} is VALID [2018-11-23 12:10:43,417 INFO L256 TraceCheckUtils]: 75: Hoare triple {13593#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {13593#false} is VALID [2018-11-23 12:10:43,417 INFO L273 TraceCheckUtils]: 76: Hoare triple {13593#false} ~cond := #in~cond; {13593#false} is VALID [2018-11-23 12:10:43,417 INFO L273 TraceCheckUtils]: 77: Hoare triple {13593#false} assume 0 == ~cond; {13593#false} is VALID [2018-11-23 12:10:43,417 INFO L273 TraceCheckUtils]: 78: Hoare triple {13593#false} assume !false; {13593#false} is VALID [2018-11-23 12:10:43,421 INFO L134 CoverageAnalysis]: Checked inductivity of 1497 backedges. 0 proven. 66 refuted. 0 times theorem prover too weak. 1431 trivial. 0 not checked. [2018-11-23 12:10:43,442 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:43,442 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [56, 14] total 60 [2018-11-23 12:10:43,443 INFO L78 Accepts]: Start accepts. Automaton has 60 states. Word has length 79 [2018-11-23 12:10:43,443 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:43,443 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 60 states. [2018-11-23 12:10:43,519 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:10:43,519 INFO L459 AbstractCegarLoop]: Interpolant automaton has 60 states [2018-11-23 12:10:43,520 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 60 interpolants. [2018-11-23 12:10:43,522 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1770, Invalid=1770, Unknown=0, NotChecked=0, Total=3540 [2018-11-23 12:10:43,522 INFO L87 Difference]: Start difference. First operand 83 states and 85 transitions. Second operand 60 states. [2018-11-23 12:10:45,586 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:45,586 INFO L93 Difference]: Finished difference Result 148 states and 169 transitions. [2018-11-23 12:10:45,587 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 60 states. [2018-11-23 12:10:45,587 INFO L78 Accepts]: Start accepts. Automaton has 60 states. Word has length 79 [2018-11-23 12:10:45,587 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:45,587 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 60 states. [2018-11-23 12:10:45,590 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 60 states to 60 states and 158 transitions. [2018-11-23 12:10:45,590 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 60 states. [2018-11-23 12:10:45,592 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 60 states to 60 states and 158 transitions. [2018-11-23 12:10:45,593 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 60 states and 158 transitions. [2018-11-23 12:10:45,860 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 158 edges. 158 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:45,863 INFO L225 Difference]: With dead ends: 148 [2018-11-23 12:10:45,863 INFO L226 Difference]: Without dead ends: 125 [2018-11-23 12:10:45,865 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 134 GetRequests, 76 SyntacticMatches, 0 SemanticMatches, 58 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 1.3s TimeCoverageRelationStatistics Valid=1770, Invalid=1770, Unknown=0, NotChecked=0, Total=3540 [2018-11-23 12:10:45,865 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 125 states. [2018-11-23 12:10:45,933 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 125 to 89. [2018-11-23 12:10:45,933 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:45,933 INFO L82 GeneralOperation]: Start isEquivalent. First operand 125 states. Second operand 89 states. [2018-11-23 12:10:45,934 INFO L74 IsIncluded]: Start isIncluded. First operand 125 states. Second operand 89 states. [2018-11-23 12:10:45,934 INFO L87 Difference]: Start difference. First operand 125 states. Second operand 89 states. [2018-11-23 12:10:45,936 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:45,936 INFO L93 Difference]: Finished difference Result 125 states and 139 transitions. [2018-11-23 12:10:45,936 INFO L276 IsEmpty]: Start isEmpty. Operand 125 states and 139 transitions. [2018-11-23 12:10:45,937 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:45,937 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:45,937 INFO L74 IsIncluded]: Start isIncluded. First operand 89 states. Second operand 125 states. [2018-11-23 12:10:45,937 INFO L87 Difference]: Start difference. First operand 89 states. Second operand 125 states. [2018-11-23 12:10:45,939 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:45,939 INFO L93 Difference]: Finished difference Result 125 states and 139 transitions. [2018-11-23 12:10:45,940 INFO L276 IsEmpty]: Start isEmpty. Operand 125 states and 139 transitions. [2018-11-23 12:10:45,940 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:45,940 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:45,940 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:45,941 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:45,941 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 89 states. [2018-11-23 12:10:45,942 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 89 states to 89 states and 91 transitions. [2018-11-23 12:10:45,942 INFO L78 Accepts]: Start accepts. Automaton has 89 states and 91 transitions. Word has length 79 [2018-11-23 12:10:45,942 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:45,942 INFO L480 AbstractCegarLoop]: Abstraction has 89 states and 91 transitions. [2018-11-23 12:10:45,942 INFO L481 AbstractCegarLoop]: Interpolant automaton has 60 states. [2018-11-23 12:10:45,942 INFO L276 IsEmpty]: Start isEmpty. Operand 89 states and 91 transitions. [2018-11-23 12:10:45,943 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 86 [2018-11-23 12:10:45,943 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:45,943 INFO L402 BasicCegarLoop]: trace histogram [58, 12, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:45,944 INFO L423 AbstractCegarLoop]: === Iteration 31 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:45,944 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:45,944 INFO L82 PathProgramCache]: Analyzing trace with hash 1784137830, now seen corresponding path program 28 times [2018-11-23 12:10:45,944 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:45,944 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:45,945 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:45,945 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:45,945 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:46,022 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:47,801 INFO L256 TraceCheckUtils]: 0: Hoare triple {14572#true} call ULTIMATE.init(); {14572#true} is VALID [2018-11-23 12:10:47,801 INFO L273 TraceCheckUtils]: 1: Hoare triple {14572#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {14572#true} is VALID [2018-11-23 12:10:47,801 INFO L273 TraceCheckUtils]: 2: Hoare triple {14572#true} assume true; {14572#true} is VALID [2018-11-23 12:10:47,802 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {14572#true} {14572#true} #60#return; {14572#true} is VALID [2018-11-23 12:10:47,802 INFO L256 TraceCheckUtils]: 4: Hoare triple {14572#true} call #t~ret4 := main(); {14572#true} is VALID [2018-11-23 12:10:47,802 INFO L273 TraceCheckUtils]: 5: Hoare triple {14572#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; {14574#(= main_~i~0 0)} is VALID [2018-11-23 12:10:47,803 INFO L273 TraceCheckUtils]: 6: Hoare triple {14574#(= 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; {14575#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:47,804 INFO L273 TraceCheckUtils]: 7: Hoare triple {14575#(<= 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; {14576#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:47,805 INFO L273 TraceCheckUtils]: 8: Hoare triple {14576#(<= 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; {14577#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:47,806 INFO L273 TraceCheckUtils]: 9: Hoare triple {14577#(<= 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; {14578#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:47,807 INFO L273 TraceCheckUtils]: 10: Hoare triple {14578#(<= 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; {14579#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:47,808 INFO L273 TraceCheckUtils]: 11: Hoare triple {14579#(<= 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; {14580#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:47,809 INFO L273 TraceCheckUtils]: 12: Hoare triple {14580#(<= 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; {14581#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:47,810 INFO L273 TraceCheckUtils]: 13: Hoare triple {14581#(<= 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; {14582#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:47,811 INFO L273 TraceCheckUtils]: 14: Hoare triple {14582#(<= 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; {14583#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:47,812 INFO L273 TraceCheckUtils]: 15: Hoare triple {14583#(<= 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; {14584#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:47,813 INFO L273 TraceCheckUtils]: 16: Hoare triple {14584#(<= 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; {14585#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:47,814 INFO L273 TraceCheckUtils]: 17: Hoare triple {14585#(<= 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; {14586#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:47,815 INFO L273 TraceCheckUtils]: 18: Hoare triple {14586#(<= 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; {14587#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:47,816 INFO L273 TraceCheckUtils]: 19: Hoare triple {14587#(<= 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; {14588#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:47,817 INFO L273 TraceCheckUtils]: 20: Hoare triple {14588#(<= 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; {14589#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:47,818 INFO L273 TraceCheckUtils]: 21: Hoare triple {14589#(<= 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; {14590#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:47,819 INFO L273 TraceCheckUtils]: 22: Hoare triple {14590#(<= 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; {14591#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:47,820 INFO L273 TraceCheckUtils]: 23: Hoare triple {14591#(<= 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; {14592#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:47,821 INFO L273 TraceCheckUtils]: 24: Hoare triple {14592#(<= 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; {14593#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:47,822 INFO L273 TraceCheckUtils]: 25: Hoare triple {14593#(<= 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; {14594#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:47,823 INFO L273 TraceCheckUtils]: 26: Hoare triple {14594#(<= 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; {14595#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:47,825 INFO L273 TraceCheckUtils]: 27: Hoare triple {14595#(<= 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; {14596#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:47,826 INFO L273 TraceCheckUtils]: 28: Hoare triple {14596#(<= 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; {14597#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:47,826 INFO L273 TraceCheckUtils]: 29: Hoare triple {14597#(<= 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; {14598#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:47,827 INFO L273 TraceCheckUtils]: 30: Hoare triple {14598#(<= 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; {14599#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:47,829 INFO L273 TraceCheckUtils]: 31: Hoare triple {14599#(<= 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; {14600#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:47,830 INFO L273 TraceCheckUtils]: 32: Hoare triple {14600#(<= 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; {14601#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:47,831 INFO L273 TraceCheckUtils]: 33: Hoare triple {14601#(<= 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; {14602#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:47,832 INFO L273 TraceCheckUtils]: 34: Hoare triple {14602#(<= 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; {14603#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:47,833 INFO L273 TraceCheckUtils]: 35: Hoare triple {14603#(<= 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; {14604#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:47,834 INFO L273 TraceCheckUtils]: 36: Hoare triple {14604#(<= 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; {14605#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:47,835 INFO L273 TraceCheckUtils]: 37: Hoare triple {14605#(<= 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; {14606#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:47,836 INFO L273 TraceCheckUtils]: 38: Hoare triple {14606#(<= 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; {14607#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:47,837 INFO L273 TraceCheckUtils]: 39: Hoare triple {14607#(<= 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; {14608#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:47,838 INFO L273 TraceCheckUtils]: 40: Hoare triple {14608#(<= 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; {14609#(<= main_~i~0 35)} is VALID [2018-11-23 12:10:47,839 INFO L273 TraceCheckUtils]: 41: Hoare triple {14609#(<= 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; {14610#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:47,840 INFO L273 TraceCheckUtils]: 42: Hoare triple {14610#(<= 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; {14611#(<= main_~i~0 37)} is VALID [2018-11-23 12:10:47,841 INFO L273 TraceCheckUtils]: 43: Hoare triple {14611#(<= 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; {14612#(<= main_~i~0 38)} is VALID [2018-11-23 12:10:47,842 INFO L273 TraceCheckUtils]: 44: Hoare triple {14612#(<= 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; {14613#(<= main_~i~0 39)} is VALID [2018-11-23 12:10:47,843 INFO L273 TraceCheckUtils]: 45: Hoare triple {14613#(<= 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; {14614#(<= main_~i~0 40)} is VALID [2018-11-23 12:10:47,844 INFO L273 TraceCheckUtils]: 46: Hoare triple {14614#(<= 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; {14615#(<= main_~i~0 41)} is VALID [2018-11-23 12:10:47,845 INFO L273 TraceCheckUtils]: 47: Hoare triple {14615#(<= 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; {14616#(<= main_~i~0 42)} is VALID [2018-11-23 12:10:47,846 INFO L273 TraceCheckUtils]: 48: Hoare triple {14616#(<= 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; {14617#(<= main_~i~0 43)} is VALID [2018-11-23 12:10:47,847 INFO L273 TraceCheckUtils]: 49: Hoare triple {14617#(<= 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; {14618#(<= main_~i~0 44)} is VALID [2018-11-23 12:10:47,848 INFO L273 TraceCheckUtils]: 50: Hoare triple {14618#(<= 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; {14619#(<= main_~i~0 45)} is VALID [2018-11-23 12:10:47,849 INFO L273 TraceCheckUtils]: 51: Hoare triple {14619#(<= 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; {14620#(<= main_~i~0 46)} is VALID [2018-11-23 12:10:47,850 INFO L273 TraceCheckUtils]: 52: Hoare triple {14620#(<= 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; {14621#(<= main_~i~0 47)} is VALID [2018-11-23 12:10:47,851 INFO L273 TraceCheckUtils]: 53: Hoare triple {14621#(<= 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; {14622#(<= main_~i~0 48)} is VALID [2018-11-23 12:10:47,852 INFO L273 TraceCheckUtils]: 54: Hoare triple {14622#(<= 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; {14623#(<= main_~i~0 49)} is VALID [2018-11-23 12:10:47,853 INFO L273 TraceCheckUtils]: 55: Hoare triple {14623#(<= 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; {14624#(<= main_~i~0 50)} is VALID [2018-11-23 12:10:47,854 INFO L273 TraceCheckUtils]: 56: Hoare triple {14624#(<= 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; {14625#(<= main_~i~0 51)} is VALID [2018-11-23 12:10:47,855 INFO L273 TraceCheckUtils]: 57: Hoare triple {14625#(<= 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; {14626#(<= main_~i~0 52)} is VALID [2018-11-23 12:10:47,856 INFO L273 TraceCheckUtils]: 58: Hoare triple {14626#(<= 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; {14627#(<= main_~i~0 53)} is VALID [2018-11-23 12:10:47,857 INFO L273 TraceCheckUtils]: 59: Hoare triple {14627#(<= 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; {14628#(<= main_~i~0 54)} is VALID [2018-11-23 12:10:47,858 INFO L273 TraceCheckUtils]: 60: Hoare triple {14628#(<= 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; {14629#(<= main_~i~0 55)} is VALID [2018-11-23 12:10:47,859 INFO L273 TraceCheckUtils]: 61: Hoare triple {14629#(<= 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; {14630#(<= main_~i~0 56)} is VALID [2018-11-23 12:10:47,860 INFO L273 TraceCheckUtils]: 62: Hoare triple {14630#(<= 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; {14631#(<= main_~i~0 57)} is VALID [2018-11-23 12:10:47,861 INFO L273 TraceCheckUtils]: 63: Hoare triple {14631#(<= 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; {14632#(<= main_~i~0 58)} is VALID [2018-11-23 12:10:47,862 INFO L273 TraceCheckUtils]: 64: Hoare triple {14632#(<= main_~i~0 58)} assume !(~i~0 < 100000); {14573#false} is VALID [2018-11-23 12:10:47,862 INFO L273 TraceCheckUtils]: 65: Hoare triple {14573#false} ~i~0 := 1; {14573#false} is VALID [2018-11-23 12:10:47,862 INFO L273 TraceCheckUtils]: 66: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:47,862 INFO L273 TraceCheckUtils]: 67: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:47,862 INFO L273 TraceCheckUtils]: 68: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:47,863 INFO L273 TraceCheckUtils]: 69: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:47,863 INFO L273 TraceCheckUtils]: 70: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:47,863 INFO L273 TraceCheckUtils]: 71: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:47,863 INFO L273 TraceCheckUtils]: 72: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:47,863 INFO L273 TraceCheckUtils]: 73: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:47,864 INFO L273 TraceCheckUtils]: 74: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:47,864 INFO L273 TraceCheckUtils]: 75: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:47,864 INFO L273 TraceCheckUtils]: 76: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:47,864 INFO L273 TraceCheckUtils]: 77: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:47,864 INFO L273 TraceCheckUtils]: 78: Hoare triple {14573#false} assume !(~i~0 < 100000); {14573#false} is VALID [2018-11-23 12:10:47,865 INFO L273 TraceCheckUtils]: 79: Hoare triple {14573#false} ~i~0 := 1;~j~0 := 0; {14573#false} is VALID [2018-11-23 12:10:47,865 INFO L273 TraceCheckUtils]: 80: Hoare triple {14573#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 + 7 * ~j~0), 4); {14573#false} is VALID [2018-11-23 12:10:47,865 INFO L256 TraceCheckUtils]: 81: Hoare triple {14573#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {14573#false} is VALID [2018-11-23 12:10:47,865 INFO L273 TraceCheckUtils]: 82: Hoare triple {14573#false} ~cond := #in~cond; {14573#false} is VALID [2018-11-23 12:10:47,865 INFO L273 TraceCheckUtils]: 83: Hoare triple {14573#false} assume 0 == ~cond; {14573#false} is VALID [2018-11-23 12:10:47,865 INFO L273 TraceCheckUtils]: 84: Hoare triple {14573#false} assume !false; {14573#false} is VALID [2018-11-23 12:10:47,870 INFO L134 CoverageAnalysis]: Checked inductivity of 1789 backedges. 0 proven. 1711 refuted. 0 times theorem prover too weak. 78 trivial. 0 not checked. [2018-11-23 12:10:47,871 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:47,871 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:10:47,880 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:10:47,965 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:10:47,966 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:48,011 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:48,013 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:48,366 INFO L256 TraceCheckUtils]: 0: Hoare triple {14572#true} call ULTIMATE.init(); {14572#true} is VALID [2018-11-23 12:10:48,366 INFO L273 TraceCheckUtils]: 1: Hoare triple {14572#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {14572#true} is VALID [2018-11-23 12:10:48,366 INFO L273 TraceCheckUtils]: 2: Hoare triple {14572#true} assume true; {14572#true} is VALID [2018-11-23 12:10:48,367 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {14572#true} {14572#true} #60#return; {14572#true} is VALID [2018-11-23 12:10:48,367 INFO L256 TraceCheckUtils]: 4: Hoare triple {14572#true} call #t~ret4 := main(); {14572#true} is VALID [2018-11-23 12:10:48,368 INFO L273 TraceCheckUtils]: 5: Hoare triple {14572#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; {14651#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:48,369 INFO L273 TraceCheckUtils]: 6: Hoare triple {14651#(<= 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; {14575#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:48,369 INFO L273 TraceCheckUtils]: 7: Hoare triple {14575#(<= 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; {14576#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:48,370 INFO L273 TraceCheckUtils]: 8: Hoare triple {14576#(<= 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; {14577#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:48,371 INFO L273 TraceCheckUtils]: 9: Hoare triple {14577#(<= 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; {14578#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:48,372 INFO L273 TraceCheckUtils]: 10: Hoare triple {14578#(<= 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; {14579#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:48,373 INFO L273 TraceCheckUtils]: 11: Hoare triple {14579#(<= 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; {14580#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:48,374 INFO L273 TraceCheckUtils]: 12: Hoare triple {14580#(<= 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; {14581#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:48,375 INFO L273 TraceCheckUtils]: 13: Hoare triple {14581#(<= 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; {14582#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:48,376 INFO L273 TraceCheckUtils]: 14: Hoare triple {14582#(<= 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; {14583#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:48,377 INFO L273 TraceCheckUtils]: 15: Hoare triple {14583#(<= 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; {14584#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:48,378 INFO L273 TraceCheckUtils]: 16: Hoare triple {14584#(<= 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; {14585#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:48,379 INFO L273 TraceCheckUtils]: 17: Hoare triple {14585#(<= 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; {14586#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:48,380 INFO L273 TraceCheckUtils]: 18: Hoare triple {14586#(<= 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; {14587#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:48,381 INFO L273 TraceCheckUtils]: 19: Hoare triple {14587#(<= 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; {14588#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:48,382 INFO L273 TraceCheckUtils]: 20: Hoare triple {14588#(<= 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; {14589#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:48,383 INFO L273 TraceCheckUtils]: 21: Hoare triple {14589#(<= 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; {14590#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:48,384 INFO L273 TraceCheckUtils]: 22: Hoare triple {14590#(<= 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; {14591#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:48,385 INFO L273 TraceCheckUtils]: 23: Hoare triple {14591#(<= 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; {14592#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:48,386 INFO L273 TraceCheckUtils]: 24: Hoare triple {14592#(<= 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; {14593#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:48,387 INFO L273 TraceCheckUtils]: 25: Hoare triple {14593#(<= 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; {14594#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:48,388 INFO L273 TraceCheckUtils]: 26: Hoare triple {14594#(<= 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; {14595#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:48,389 INFO L273 TraceCheckUtils]: 27: Hoare triple {14595#(<= 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; {14596#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:48,390 INFO L273 TraceCheckUtils]: 28: Hoare triple {14596#(<= 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; {14597#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:48,391 INFO L273 TraceCheckUtils]: 29: Hoare triple {14597#(<= 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; {14598#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:48,392 INFO L273 TraceCheckUtils]: 30: Hoare triple {14598#(<= 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; {14599#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:48,393 INFO L273 TraceCheckUtils]: 31: Hoare triple {14599#(<= 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; {14600#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:48,394 INFO L273 TraceCheckUtils]: 32: Hoare triple {14600#(<= 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; {14601#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:48,395 INFO L273 TraceCheckUtils]: 33: Hoare triple {14601#(<= 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; {14602#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:48,396 INFO L273 TraceCheckUtils]: 34: Hoare triple {14602#(<= 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; {14603#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:48,397 INFO L273 TraceCheckUtils]: 35: Hoare triple {14603#(<= 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; {14604#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:48,398 INFO L273 TraceCheckUtils]: 36: Hoare triple {14604#(<= 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; {14605#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:48,399 INFO L273 TraceCheckUtils]: 37: Hoare triple {14605#(<= 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; {14606#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:48,400 INFO L273 TraceCheckUtils]: 38: Hoare triple {14606#(<= 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; {14607#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:48,401 INFO L273 TraceCheckUtils]: 39: Hoare triple {14607#(<= 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; {14608#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:48,402 INFO L273 TraceCheckUtils]: 40: Hoare triple {14608#(<= 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; {14609#(<= main_~i~0 35)} is VALID [2018-11-23 12:10:48,403 INFO L273 TraceCheckUtils]: 41: Hoare triple {14609#(<= 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; {14610#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:48,404 INFO L273 TraceCheckUtils]: 42: Hoare triple {14610#(<= 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; {14611#(<= main_~i~0 37)} is VALID [2018-11-23 12:10:48,405 INFO L273 TraceCheckUtils]: 43: Hoare triple {14611#(<= 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; {14612#(<= main_~i~0 38)} is VALID [2018-11-23 12:10:48,406 INFO L273 TraceCheckUtils]: 44: Hoare triple {14612#(<= 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; {14613#(<= main_~i~0 39)} is VALID [2018-11-23 12:10:48,407 INFO L273 TraceCheckUtils]: 45: Hoare triple {14613#(<= 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; {14614#(<= main_~i~0 40)} is VALID [2018-11-23 12:10:48,408 INFO L273 TraceCheckUtils]: 46: Hoare triple {14614#(<= 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; {14615#(<= main_~i~0 41)} is VALID [2018-11-23 12:10:48,409 INFO L273 TraceCheckUtils]: 47: Hoare triple {14615#(<= 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; {14616#(<= main_~i~0 42)} is VALID [2018-11-23 12:10:48,410 INFO L273 TraceCheckUtils]: 48: Hoare triple {14616#(<= 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; {14617#(<= main_~i~0 43)} is VALID [2018-11-23 12:10:48,411 INFO L273 TraceCheckUtils]: 49: Hoare triple {14617#(<= 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; {14618#(<= main_~i~0 44)} is VALID [2018-11-23 12:10:48,412 INFO L273 TraceCheckUtils]: 50: Hoare triple {14618#(<= 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; {14619#(<= main_~i~0 45)} is VALID [2018-11-23 12:10:48,413 INFO L273 TraceCheckUtils]: 51: Hoare triple {14619#(<= 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; {14620#(<= main_~i~0 46)} is VALID [2018-11-23 12:10:48,414 INFO L273 TraceCheckUtils]: 52: Hoare triple {14620#(<= 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; {14621#(<= main_~i~0 47)} is VALID [2018-11-23 12:10:48,415 INFO L273 TraceCheckUtils]: 53: Hoare triple {14621#(<= 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; {14622#(<= main_~i~0 48)} is VALID [2018-11-23 12:10:48,416 INFO L273 TraceCheckUtils]: 54: Hoare triple {14622#(<= 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; {14623#(<= main_~i~0 49)} is VALID [2018-11-23 12:10:48,417 INFO L273 TraceCheckUtils]: 55: Hoare triple {14623#(<= 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; {14624#(<= main_~i~0 50)} is VALID [2018-11-23 12:10:48,418 INFO L273 TraceCheckUtils]: 56: Hoare triple {14624#(<= 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; {14625#(<= main_~i~0 51)} is VALID [2018-11-23 12:10:48,419 INFO L273 TraceCheckUtils]: 57: Hoare triple {14625#(<= 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; {14626#(<= main_~i~0 52)} is VALID [2018-11-23 12:10:48,420 INFO L273 TraceCheckUtils]: 58: Hoare triple {14626#(<= 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; {14627#(<= main_~i~0 53)} is VALID [2018-11-23 12:10:48,421 INFO L273 TraceCheckUtils]: 59: Hoare triple {14627#(<= 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; {14628#(<= main_~i~0 54)} is VALID [2018-11-23 12:10:48,422 INFO L273 TraceCheckUtils]: 60: Hoare triple {14628#(<= 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; {14629#(<= main_~i~0 55)} is VALID [2018-11-23 12:10:48,423 INFO L273 TraceCheckUtils]: 61: Hoare triple {14629#(<= 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; {14630#(<= main_~i~0 56)} is VALID [2018-11-23 12:10:48,424 INFO L273 TraceCheckUtils]: 62: Hoare triple {14630#(<= 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; {14631#(<= main_~i~0 57)} is VALID [2018-11-23 12:10:48,425 INFO L273 TraceCheckUtils]: 63: Hoare triple {14631#(<= 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; {14632#(<= main_~i~0 58)} is VALID [2018-11-23 12:10:48,426 INFO L273 TraceCheckUtils]: 64: Hoare triple {14632#(<= main_~i~0 58)} assume !(~i~0 < 100000); {14573#false} is VALID [2018-11-23 12:10:48,426 INFO L273 TraceCheckUtils]: 65: Hoare triple {14573#false} ~i~0 := 1; {14573#false} is VALID [2018-11-23 12:10:48,426 INFO L273 TraceCheckUtils]: 66: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:48,427 INFO L273 TraceCheckUtils]: 67: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:48,427 INFO L273 TraceCheckUtils]: 68: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:48,427 INFO L273 TraceCheckUtils]: 69: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:48,427 INFO L273 TraceCheckUtils]: 70: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:48,427 INFO L273 TraceCheckUtils]: 71: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:48,428 INFO L273 TraceCheckUtils]: 72: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:48,428 INFO L273 TraceCheckUtils]: 73: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:48,428 INFO L273 TraceCheckUtils]: 74: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:48,428 INFO L273 TraceCheckUtils]: 75: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:48,428 INFO L273 TraceCheckUtils]: 76: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:48,429 INFO L273 TraceCheckUtils]: 77: Hoare triple {14573#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {14573#false} is VALID [2018-11-23 12:10:48,429 INFO L273 TraceCheckUtils]: 78: Hoare triple {14573#false} assume !(~i~0 < 100000); {14573#false} is VALID [2018-11-23 12:10:48,429 INFO L273 TraceCheckUtils]: 79: Hoare triple {14573#false} ~i~0 := 1;~j~0 := 0; {14573#false} is VALID [2018-11-23 12:10:48,429 INFO L273 TraceCheckUtils]: 80: Hoare triple {14573#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 + 7 * ~j~0), 4); {14573#false} is VALID [2018-11-23 12:10:48,429 INFO L256 TraceCheckUtils]: 81: Hoare triple {14573#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {14573#false} is VALID [2018-11-23 12:10:48,429 INFO L273 TraceCheckUtils]: 82: Hoare triple {14573#false} ~cond := #in~cond; {14573#false} is VALID [2018-11-23 12:10:48,429 INFO L273 TraceCheckUtils]: 83: Hoare triple {14573#false} assume 0 == ~cond; {14573#false} is VALID [2018-11-23 12:10:48,430 INFO L273 TraceCheckUtils]: 84: Hoare triple {14573#false} assume !false; {14573#false} is VALID [2018-11-23 12:10:48,435 INFO L134 CoverageAnalysis]: Checked inductivity of 1789 backedges. 0 proven. 1711 refuted. 0 times theorem prover too weak. 78 trivial. 0 not checked. [2018-11-23 12:10:48,455 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:48,455 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [61, 61] total 62 [2018-11-23 12:10:48,456 INFO L78 Accepts]: Start accepts. Automaton has 62 states. Word has length 85 [2018-11-23 12:10:48,456 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:48,456 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 62 states. [2018-11-23 12:10:48,514 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:10:48,514 INFO L459 AbstractCegarLoop]: Interpolant automaton has 62 states [2018-11-23 12:10:48,515 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 62 interpolants. [2018-11-23 12:10:48,517 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1891, Invalid=1891, Unknown=0, NotChecked=0, Total=3782 [2018-11-23 12:10:48,517 INFO L87 Difference]: Start difference. First operand 89 states and 91 transitions. Second operand 62 states. [2018-11-23 12:10:50,634 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:50,634 INFO L93 Difference]: Finished difference Result 141 states and 154 transitions. [2018-11-23 12:10:50,634 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 61 states. [2018-11-23 12:10:50,634 INFO L78 Accepts]: Start accepts. Automaton has 62 states. Word has length 85 [2018-11-23 12:10:50,635 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:50,635 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 62 states. [2018-11-23 12:10:50,636 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 61 states to 61 states and 139 transitions. [2018-11-23 12:10:50,636 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 62 states. [2018-11-23 12:10:50,638 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 61 states to 61 states and 139 transitions. [2018-11-23 12:10:50,638 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 61 states and 139 transitions. [2018-11-23 12:10:50,813 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 139 edges. 139 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:50,815 INFO L225 Difference]: With dead ends: 141 [2018-11-23 12:10:50,815 INFO L226 Difference]: Without dead ends: 117 [2018-11-23 12:10:50,817 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 145 GetRequests, 85 SyntacticMatches, 0 SemanticMatches, 60 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 114 ImplicationChecksByTransitivity, 1.5s TimeCoverageRelationStatistics Valid=1891, Invalid=1891, Unknown=0, NotChecked=0, Total=3782 [2018-11-23 12:10:50,817 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 117 states. [2018-11-23 12:10:50,880 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 117 to 90. [2018-11-23 12:10:50,880 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:50,880 INFO L82 GeneralOperation]: Start isEquivalent. First operand 117 states. Second operand 90 states. [2018-11-23 12:10:50,880 INFO L74 IsIncluded]: Start isIncluded. First operand 117 states. Second operand 90 states. [2018-11-23 12:10:50,880 INFO L87 Difference]: Start difference. First operand 117 states. Second operand 90 states. [2018-11-23 12:10:50,882 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:50,882 INFO L93 Difference]: Finished difference Result 117 states and 128 transitions. [2018-11-23 12:10:50,882 INFO L276 IsEmpty]: Start isEmpty. Operand 117 states and 128 transitions. [2018-11-23 12:10:50,883 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:50,883 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:50,883 INFO L74 IsIncluded]: Start isIncluded. First operand 90 states. Second operand 117 states. [2018-11-23 12:10:50,883 INFO L87 Difference]: Start difference. First operand 90 states. Second operand 117 states. [2018-11-23 12:10:50,885 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:50,886 INFO L93 Difference]: Finished difference Result 117 states and 128 transitions. [2018-11-23 12:10:50,886 INFO L276 IsEmpty]: Start isEmpty. Operand 117 states and 128 transitions. [2018-11-23 12:10:50,886 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:50,886 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:50,887 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:50,887 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:50,887 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 90 states. [2018-11-23 12:10:50,888 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 90 states to 90 states and 92 transitions. [2018-11-23 12:10:50,888 INFO L78 Accepts]: Start accepts. Automaton has 90 states and 92 transitions. Word has length 85 [2018-11-23 12:10:50,888 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:50,889 INFO L480 AbstractCegarLoop]: Abstraction has 90 states and 92 transitions. [2018-11-23 12:10:50,889 INFO L481 AbstractCegarLoop]: Interpolant automaton has 62 states. [2018-11-23 12:10:50,889 INFO L276 IsEmpty]: Start isEmpty. Operand 90 states and 92 transitions. [2018-11-23 12:10:50,889 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 87 [2018-11-23 12:10:50,889 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:50,890 INFO L402 BasicCegarLoop]: trace histogram [59, 12, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:50,890 INFO L423 AbstractCegarLoop]: === Iteration 32 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:50,890 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:50,890 INFO L82 PathProgramCache]: Analyzing trace with hash -13995638, now seen corresponding path program 29 times [2018-11-23 12:10:50,890 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:50,890 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:50,891 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:50,891 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:50,891 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:50,976 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:52,684 INFO L256 TraceCheckUtils]: 0: Hoare triple {15547#true} call ULTIMATE.init(); {15547#true} is VALID [2018-11-23 12:10:52,684 INFO L273 TraceCheckUtils]: 1: Hoare triple {15547#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {15547#true} is VALID [2018-11-23 12:10:52,684 INFO L273 TraceCheckUtils]: 2: Hoare triple {15547#true} assume true; {15547#true} is VALID [2018-11-23 12:10:52,684 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {15547#true} {15547#true} #60#return; {15547#true} is VALID [2018-11-23 12:10:52,685 INFO L256 TraceCheckUtils]: 4: Hoare triple {15547#true} call #t~ret4 := main(); {15547#true} is VALID [2018-11-23 12:10:52,685 INFO L273 TraceCheckUtils]: 5: Hoare triple {15547#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; {15549#(= main_~i~0 0)} is VALID [2018-11-23 12:10:52,686 INFO L273 TraceCheckUtils]: 6: Hoare triple {15549#(= 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; {15550#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:52,687 INFO L273 TraceCheckUtils]: 7: Hoare triple {15550#(<= 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; {15551#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:52,688 INFO L273 TraceCheckUtils]: 8: Hoare triple {15551#(<= 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; {15552#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:52,689 INFO L273 TraceCheckUtils]: 9: Hoare triple {15552#(<= 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; {15553#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:52,689 INFO L273 TraceCheckUtils]: 10: Hoare triple {15553#(<= 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; {15554#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:52,690 INFO L273 TraceCheckUtils]: 11: Hoare triple {15554#(<= 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; {15555#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:52,691 INFO L273 TraceCheckUtils]: 12: Hoare triple {15555#(<= 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; {15556#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:52,692 INFO L273 TraceCheckUtils]: 13: Hoare triple {15556#(<= 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; {15557#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:52,693 INFO L273 TraceCheckUtils]: 14: Hoare triple {15557#(<= 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; {15558#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:52,694 INFO L273 TraceCheckUtils]: 15: Hoare triple {15558#(<= 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; {15559#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:52,695 INFO L273 TraceCheckUtils]: 16: Hoare triple {15559#(<= 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; {15560#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:52,696 INFO L273 TraceCheckUtils]: 17: Hoare triple {15560#(<= 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; {15561#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:52,697 INFO L273 TraceCheckUtils]: 18: Hoare triple {15561#(<= 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; {15562#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:52,698 INFO L273 TraceCheckUtils]: 19: Hoare triple {15562#(<= 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; {15563#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:52,699 INFO L273 TraceCheckUtils]: 20: Hoare triple {15563#(<= 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; {15564#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:52,708 INFO L273 TraceCheckUtils]: 21: Hoare triple {15564#(<= 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; {15565#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:52,709 INFO L273 TraceCheckUtils]: 22: Hoare triple {15565#(<= 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; {15566#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:52,709 INFO L273 TraceCheckUtils]: 23: Hoare triple {15566#(<= 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; {15567#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:52,710 INFO L273 TraceCheckUtils]: 24: Hoare triple {15567#(<= 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; {15568#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:52,711 INFO L273 TraceCheckUtils]: 25: Hoare triple {15568#(<= 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; {15569#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:52,711 INFO L273 TraceCheckUtils]: 26: Hoare triple {15569#(<= 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; {15570#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:52,712 INFO L273 TraceCheckUtils]: 27: Hoare triple {15570#(<= 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; {15571#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:52,713 INFO L273 TraceCheckUtils]: 28: Hoare triple {15571#(<= 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; {15572#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:52,714 INFO L273 TraceCheckUtils]: 29: Hoare triple {15572#(<= 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; {15573#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:52,715 INFO L273 TraceCheckUtils]: 30: Hoare triple {15573#(<= 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; {15574#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:52,716 INFO L273 TraceCheckUtils]: 31: Hoare triple {15574#(<= 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; {15575#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:52,717 INFO L273 TraceCheckUtils]: 32: Hoare triple {15575#(<= 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; {15576#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:52,718 INFO L273 TraceCheckUtils]: 33: Hoare triple {15576#(<= 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; {15577#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:52,719 INFO L273 TraceCheckUtils]: 34: Hoare triple {15577#(<= 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; {15578#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:52,720 INFO L273 TraceCheckUtils]: 35: Hoare triple {15578#(<= 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; {15579#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:52,721 INFO L273 TraceCheckUtils]: 36: Hoare triple {15579#(<= 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; {15580#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:52,722 INFO L273 TraceCheckUtils]: 37: Hoare triple {15580#(<= 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; {15581#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:52,723 INFO L273 TraceCheckUtils]: 38: Hoare triple {15581#(<= 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; {15582#(<= main_~i~0 33)} is VALID [2018-11-23 12:10:52,724 INFO L273 TraceCheckUtils]: 39: Hoare triple {15582#(<= 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; {15583#(<= main_~i~0 34)} is VALID [2018-11-23 12:10:52,725 INFO L273 TraceCheckUtils]: 40: Hoare triple {15583#(<= 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; {15584#(<= main_~i~0 35)} is VALID [2018-11-23 12:10:52,726 INFO L273 TraceCheckUtils]: 41: Hoare triple {15584#(<= 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; {15585#(<= main_~i~0 36)} is VALID [2018-11-23 12:10:52,727 INFO L273 TraceCheckUtils]: 42: Hoare triple {15585#(<= 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; {15586#(<= main_~i~0 37)} is VALID [2018-11-23 12:10:52,728 INFO L273 TraceCheckUtils]: 43: Hoare triple {15586#(<= 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; {15587#(<= main_~i~0 38)} is VALID [2018-11-23 12:10:52,729 INFO L273 TraceCheckUtils]: 44: Hoare triple {15587#(<= 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; {15588#(<= main_~i~0 39)} is VALID [2018-11-23 12:10:52,730 INFO L273 TraceCheckUtils]: 45: Hoare triple {15588#(<= 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; {15589#(<= main_~i~0 40)} is VALID [2018-11-23 12:10:52,731 INFO L273 TraceCheckUtils]: 46: Hoare triple {15589#(<= 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; {15590#(<= main_~i~0 41)} is VALID [2018-11-23 12:10:52,732 INFO L273 TraceCheckUtils]: 47: Hoare triple {15590#(<= 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; {15591#(<= main_~i~0 42)} is VALID [2018-11-23 12:10:52,733 INFO L273 TraceCheckUtils]: 48: Hoare triple {15591#(<= 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; {15592#(<= main_~i~0 43)} is VALID [2018-11-23 12:10:52,734 INFO L273 TraceCheckUtils]: 49: Hoare triple {15592#(<= 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; {15593#(<= main_~i~0 44)} is VALID [2018-11-23 12:10:52,735 INFO L273 TraceCheckUtils]: 50: Hoare triple {15593#(<= 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; {15594#(<= main_~i~0 45)} is VALID [2018-11-23 12:10:52,736 INFO L273 TraceCheckUtils]: 51: Hoare triple {15594#(<= 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; {15595#(<= main_~i~0 46)} is VALID [2018-11-23 12:10:52,737 INFO L273 TraceCheckUtils]: 52: Hoare triple {15595#(<= 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; {15596#(<= main_~i~0 47)} is VALID [2018-11-23 12:10:52,738 INFO L273 TraceCheckUtils]: 53: Hoare triple {15596#(<= 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; {15597#(<= main_~i~0 48)} is VALID [2018-11-23 12:10:52,739 INFO L273 TraceCheckUtils]: 54: Hoare triple {15597#(<= 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; {15598#(<= main_~i~0 49)} is VALID [2018-11-23 12:10:52,741 INFO L273 TraceCheckUtils]: 55: Hoare triple {15598#(<= 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; {15599#(<= main_~i~0 50)} is VALID [2018-11-23 12:10:52,742 INFO L273 TraceCheckUtils]: 56: Hoare triple {15599#(<= 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; {15600#(<= main_~i~0 51)} is VALID [2018-11-23 12:10:52,743 INFO L273 TraceCheckUtils]: 57: Hoare triple {15600#(<= 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; {15601#(<= main_~i~0 52)} is VALID [2018-11-23 12:10:52,744 INFO L273 TraceCheckUtils]: 58: Hoare triple {15601#(<= 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; {15602#(<= main_~i~0 53)} is VALID [2018-11-23 12:10:52,745 INFO L273 TraceCheckUtils]: 59: Hoare triple {15602#(<= 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; {15603#(<= main_~i~0 54)} is VALID [2018-11-23 12:10:52,764 INFO L273 TraceCheckUtils]: 60: Hoare triple {15603#(<= 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; {15604#(<= main_~i~0 55)} is VALID [2018-11-23 12:10:52,773 INFO L273 TraceCheckUtils]: 61: Hoare triple {15604#(<= 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; {15605#(<= main_~i~0 56)} is VALID [2018-11-23 12:10:52,774 INFO L273 TraceCheckUtils]: 62: Hoare triple {15605#(<= 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; {15606#(<= main_~i~0 57)} is VALID [2018-11-23 12:10:52,775 INFO L273 TraceCheckUtils]: 63: Hoare triple {15606#(<= 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; {15607#(<= main_~i~0 58)} is VALID [2018-11-23 12:10:52,775 INFO L273 TraceCheckUtils]: 64: Hoare triple {15607#(<= 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; {15608#(<= main_~i~0 59)} is VALID [2018-11-23 12:10:52,776 INFO L273 TraceCheckUtils]: 65: Hoare triple {15608#(<= main_~i~0 59)} assume !(~i~0 < 100000); {15548#false} is VALID [2018-11-23 12:10:52,776 INFO L273 TraceCheckUtils]: 66: Hoare triple {15548#false} ~i~0 := 1; {15548#false} is VALID [2018-11-23 12:10:52,776 INFO L273 TraceCheckUtils]: 67: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:10:52,776 INFO L273 TraceCheckUtils]: 68: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:10:52,776 INFO L273 TraceCheckUtils]: 69: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:10:52,776 INFO L273 TraceCheckUtils]: 70: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:10:52,776 INFO L273 TraceCheckUtils]: 71: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:10:52,777 INFO L273 TraceCheckUtils]: 72: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:10:52,777 INFO L273 TraceCheckUtils]: 73: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:10:52,777 INFO L273 TraceCheckUtils]: 74: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:10:52,777 INFO L273 TraceCheckUtils]: 75: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:10:52,777 INFO L273 TraceCheckUtils]: 76: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:10:52,777 INFO L273 TraceCheckUtils]: 77: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:10:52,777 INFO L273 TraceCheckUtils]: 78: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:10:52,777 INFO L273 TraceCheckUtils]: 79: Hoare triple {15548#false} assume !(~i~0 < 100000); {15548#false} is VALID [2018-11-23 12:10:52,778 INFO L273 TraceCheckUtils]: 80: Hoare triple {15548#false} ~i~0 := 1;~j~0 := 0; {15548#false} is VALID [2018-11-23 12:10:52,778 INFO L273 TraceCheckUtils]: 81: Hoare triple {15548#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 + 7 * ~j~0), 4); {15548#false} is VALID [2018-11-23 12:10:52,778 INFO L256 TraceCheckUtils]: 82: Hoare triple {15548#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {15548#false} is VALID [2018-11-23 12:10:52,778 INFO L273 TraceCheckUtils]: 83: Hoare triple {15548#false} ~cond := #in~cond; {15548#false} is VALID [2018-11-23 12:10:52,778 INFO L273 TraceCheckUtils]: 84: Hoare triple {15548#false} assume 0 == ~cond; {15548#false} is VALID [2018-11-23 12:10:52,779 INFO L273 TraceCheckUtils]: 85: Hoare triple {15548#false} assume !false; {15548#false} is VALID [2018-11-23 12:10:52,784 INFO L134 CoverageAnalysis]: Checked inductivity of 1848 backedges. 0 proven. 1770 refuted. 0 times theorem prover too weak. 78 trivial. 0 not checked. [2018-11-23 12:10:52,784 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:52,784 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:10:52,795 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:12:06,115 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 31 check-sat command(s) [2018-11-23 12:12:06,115 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:12:06,206 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:12:06,208 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:12:06,700 INFO L256 TraceCheckUtils]: 0: Hoare triple {15547#true} call ULTIMATE.init(); {15547#true} is VALID [2018-11-23 12:12:06,700 INFO L273 TraceCheckUtils]: 1: Hoare triple {15547#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {15547#true} is VALID [2018-11-23 12:12:06,701 INFO L273 TraceCheckUtils]: 2: Hoare triple {15547#true} assume true; {15547#true} is VALID [2018-11-23 12:12:06,701 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {15547#true} {15547#true} #60#return; {15547#true} is VALID [2018-11-23 12:12:06,701 INFO L256 TraceCheckUtils]: 4: Hoare triple {15547#true} call #t~ret4 := main(); {15547#true} is VALID [2018-11-23 12:12:06,704 INFO L273 TraceCheckUtils]: 5: Hoare triple {15547#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; {15627#(<= main_~i~0 0)} is VALID [2018-11-23 12:12:06,706 INFO L273 TraceCheckUtils]: 6: Hoare triple {15627#(<= 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; {15550#(<= main_~i~0 1)} is VALID [2018-11-23 12:12:06,706 INFO L273 TraceCheckUtils]: 7: Hoare triple {15550#(<= 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; {15551#(<= main_~i~0 2)} is VALID [2018-11-23 12:12:06,707 INFO L273 TraceCheckUtils]: 8: Hoare triple {15551#(<= 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; {15552#(<= main_~i~0 3)} is VALID [2018-11-23 12:12:06,708 INFO L273 TraceCheckUtils]: 9: Hoare triple {15552#(<= 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; {15553#(<= main_~i~0 4)} is VALID [2018-11-23 12:12:06,708 INFO L273 TraceCheckUtils]: 10: Hoare triple {15553#(<= 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; {15554#(<= main_~i~0 5)} is VALID [2018-11-23 12:12:06,709 INFO L273 TraceCheckUtils]: 11: Hoare triple {15554#(<= 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; {15555#(<= main_~i~0 6)} is VALID [2018-11-23 12:12:06,710 INFO L273 TraceCheckUtils]: 12: Hoare triple {15555#(<= 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; {15556#(<= main_~i~0 7)} is VALID [2018-11-23 12:12:06,711 INFO L273 TraceCheckUtils]: 13: Hoare triple {15556#(<= 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; {15557#(<= main_~i~0 8)} is VALID [2018-11-23 12:12:06,712 INFO L273 TraceCheckUtils]: 14: Hoare triple {15557#(<= 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; {15558#(<= main_~i~0 9)} is VALID [2018-11-23 12:12:06,713 INFO L273 TraceCheckUtils]: 15: Hoare triple {15558#(<= 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; {15559#(<= main_~i~0 10)} is VALID [2018-11-23 12:12:06,714 INFO L273 TraceCheckUtils]: 16: Hoare triple {15559#(<= 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; {15560#(<= main_~i~0 11)} is VALID [2018-11-23 12:12:06,715 INFO L273 TraceCheckUtils]: 17: Hoare triple {15560#(<= 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; {15561#(<= main_~i~0 12)} is VALID [2018-11-23 12:12:06,716 INFO L273 TraceCheckUtils]: 18: Hoare triple {15561#(<= 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; {15562#(<= main_~i~0 13)} is VALID [2018-11-23 12:12:06,717 INFO L273 TraceCheckUtils]: 19: Hoare triple {15562#(<= 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; {15563#(<= main_~i~0 14)} is VALID [2018-11-23 12:12:06,718 INFO L273 TraceCheckUtils]: 20: Hoare triple {15563#(<= 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; {15564#(<= main_~i~0 15)} is VALID [2018-11-23 12:12:06,719 INFO L273 TraceCheckUtils]: 21: Hoare triple {15564#(<= 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; {15565#(<= main_~i~0 16)} is VALID [2018-11-23 12:12:06,720 INFO L273 TraceCheckUtils]: 22: Hoare triple {15565#(<= 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; {15566#(<= main_~i~0 17)} is VALID [2018-11-23 12:12:06,721 INFO L273 TraceCheckUtils]: 23: Hoare triple {15566#(<= 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; {15567#(<= main_~i~0 18)} is VALID [2018-11-23 12:12:06,722 INFO L273 TraceCheckUtils]: 24: Hoare triple {15567#(<= 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; {15568#(<= main_~i~0 19)} is VALID [2018-11-23 12:12:06,723 INFO L273 TraceCheckUtils]: 25: Hoare triple {15568#(<= 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; {15569#(<= main_~i~0 20)} is VALID [2018-11-23 12:12:06,724 INFO L273 TraceCheckUtils]: 26: Hoare triple {15569#(<= 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; {15570#(<= main_~i~0 21)} is VALID [2018-11-23 12:12:06,725 INFO L273 TraceCheckUtils]: 27: Hoare triple {15570#(<= 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; {15571#(<= main_~i~0 22)} is VALID [2018-11-23 12:12:06,726 INFO L273 TraceCheckUtils]: 28: Hoare triple {15571#(<= 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; {15572#(<= main_~i~0 23)} is VALID [2018-11-23 12:12:06,727 INFO L273 TraceCheckUtils]: 29: Hoare triple {15572#(<= 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; {15573#(<= main_~i~0 24)} is VALID [2018-11-23 12:12:06,728 INFO L273 TraceCheckUtils]: 30: Hoare triple {15573#(<= 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; {15574#(<= main_~i~0 25)} is VALID [2018-11-23 12:12:06,729 INFO L273 TraceCheckUtils]: 31: Hoare triple {15574#(<= 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; {15575#(<= main_~i~0 26)} is VALID [2018-11-23 12:12:06,730 INFO L273 TraceCheckUtils]: 32: Hoare triple {15575#(<= 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; {15576#(<= main_~i~0 27)} is VALID [2018-11-23 12:12:06,731 INFO L273 TraceCheckUtils]: 33: Hoare triple {15576#(<= 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; {15577#(<= main_~i~0 28)} is VALID [2018-11-23 12:12:06,732 INFO L273 TraceCheckUtils]: 34: Hoare triple {15577#(<= 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; {15578#(<= main_~i~0 29)} is VALID [2018-11-23 12:12:06,733 INFO L273 TraceCheckUtils]: 35: Hoare triple {15578#(<= 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; {15579#(<= main_~i~0 30)} is VALID [2018-11-23 12:12:06,734 INFO L273 TraceCheckUtils]: 36: Hoare triple {15579#(<= 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; {15580#(<= main_~i~0 31)} is VALID [2018-11-23 12:12:06,735 INFO L273 TraceCheckUtils]: 37: Hoare triple {15580#(<= 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; {15581#(<= main_~i~0 32)} is VALID [2018-11-23 12:12:06,736 INFO L273 TraceCheckUtils]: 38: Hoare triple {15581#(<= 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; {15582#(<= main_~i~0 33)} is VALID [2018-11-23 12:12:06,737 INFO L273 TraceCheckUtils]: 39: Hoare triple {15582#(<= 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; {15583#(<= main_~i~0 34)} is VALID [2018-11-23 12:12:06,738 INFO L273 TraceCheckUtils]: 40: Hoare triple {15583#(<= 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; {15584#(<= main_~i~0 35)} is VALID [2018-11-23 12:12:06,739 INFO L273 TraceCheckUtils]: 41: Hoare triple {15584#(<= 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; {15585#(<= main_~i~0 36)} is VALID [2018-11-23 12:12:06,740 INFO L273 TraceCheckUtils]: 42: Hoare triple {15585#(<= 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; {15586#(<= main_~i~0 37)} is VALID [2018-11-23 12:12:06,741 INFO L273 TraceCheckUtils]: 43: Hoare triple {15586#(<= 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; {15587#(<= main_~i~0 38)} is VALID [2018-11-23 12:12:06,742 INFO L273 TraceCheckUtils]: 44: Hoare triple {15587#(<= 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; {15588#(<= main_~i~0 39)} is VALID [2018-11-23 12:12:06,743 INFO L273 TraceCheckUtils]: 45: Hoare triple {15588#(<= 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; {15589#(<= main_~i~0 40)} is VALID [2018-11-23 12:12:06,744 INFO L273 TraceCheckUtils]: 46: Hoare triple {15589#(<= 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; {15590#(<= main_~i~0 41)} is VALID [2018-11-23 12:12:06,745 INFO L273 TraceCheckUtils]: 47: Hoare triple {15590#(<= 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; {15591#(<= main_~i~0 42)} is VALID [2018-11-23 12:12:06,746 INFO L273 TraceCheckUtils]: 48: Hoare triple {15591#(<= 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; {15592#(<= main_~i~0 43)} is VALID [2018-11-23 12:12:06,747 INFO L273 TraceCheckUtils]: 49: Hoare triple {15592#(<= 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; {15593#(<= main_~i~0 44)} is VALID [2018-11-23 12:12:06,748 INFO L273 TraceCheckUtils]: 50: Hoare triple {15593#(<= 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; {15594#(<= main_~i~0 45)} is VALID [2018-11-23 12:12:06,749 INFO L273 TraceCheckUtils]: 51: Hoare triple {15594#(<= 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; {15595#(<= main_~i~0 46)} is VALID [2018-11-23 12:12:06,750 INFO L273 TraceCheckUtils]: 52: Hoare triple {15595#(<= 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; {15596#(<= main_~i~0 47)} is VALID [2018-11-23 12:12:06,751 INFO L273 TraceCheckUtils]: 53: Hoare triple {15596#(<= 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; {15597#(<= main_~i~0 48)} is VALID [2018-11-23 12:12:06,751 INFO L273 TraceCheckUtils]: 54: Hoare triple {15597#(<= 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; {15598#(<= main_~i~0 49)} is VALID [2018-11-23 12:12:06,752 INFO L273 TraceCheckUtils]: 55: Hoare triple {15598#(<= 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; {15599#(<= main_~i~0 50)} is VALID [2018-11-23 12:12:06,753 INFO L273 TraceCheckUtils]: 56: Hoare triple {15599#(<= 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; {15600#(<= main_~i~0 51)} is VALID [2018-11-23 12:12:06,754 INFO L273 TraceCheckUtils]: 57: Hoare triple {15600#(<= 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; {15601#(<= main_~i~0 52)} is VALID [2018-11-23 12:12:06,755 INFO L273 TraceCheckUtils]: 58: Hoare triple {15601#(<= 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; {15602#(<= main_~i~0 53)} is VALID [2018-11-23 12:12:06,756 INFO L273 TraceCheckUtils]: 59: Hoare triple {15602#(<= 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; {15603#(<= main_~i~0 54)} is VALID [2018-11-23 12:12:06,757 INFO L273 TraceCheckUtils]: 60: Hoare triple {15603#(<= 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; {15604#(<= main_~i~0 55)} is VALID [2018-11-23 12:12:06,758 INFO L273 TraceCheckUtils]: 61: Hoare triple {15604#(<= 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; {15605#(<= main_~i~0 56)} is VALID [2018-11-23 12:12:06,759 INFO L273 TraceCheckUtils]: 62: Hoare triple {15605#(<= 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; {15606#(<= main_~i~0 57)} is VALID [2018-11-23 12:12:06,760 INFO L273 TraceCheckUtils]: 63: Hoare triple {15606#(<= 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; {15607#(<= main_~i~0 58)} is VALID [2018-11-23 12:12:06,761 INFO L273 TraceCheckUtils]: 64: Hoare triple {15607#(<= 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; {15608#(<= main_~i~0 59)} is VALID [2018-11-23 12:12:06,762 INFO L273 TraceCheckUtils]: 65: Hoare triple {15608#(<= main_~i~0 59)} assume !(~i~0 < 100000); {15548#false} is VALID [2018-11-23 12:12:06,762 INFO L273 TraceCheckUtils]: 66: Hoare triple {15548#false} ~i~0 := 1; {15548#false} is VALID [2018-11-23 12:12:06,762 INFO L273 TraceCheckUtils]: 67: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:12:06,762 INFO L273 TraceCheckUtils]: 68: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:12:06,763 INFO L273 TraceCheckUtils]: 69: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:12:06,763 INFO L273 TraceCheckUtils]: 70: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:12:06,763 INFO L273 TraceCheckUtils]: 71: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:12:06,763 INFO L273 TraceCheckUtils]: 72: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:12:06,764 INFO L273 TraceCheckUtils]: 73: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:12:06,764 INFO L273 TraceCheckUtils]: 74: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:12:06,764 INFO L273 TraceCheckUtils]: 75: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:12:06,764 INFO L273 TraceCheckUtils]: 76: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:12:06,765 INFO L273 TraceCheckUtils]: 77: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:12:06,765 INFO L273 TraceCheckUtils]: 78: Hoare triple {15548#false} assume !!(~i~0 < 100000);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem1, ~#a~0.base, ~#a~0.offset + 4 * ~j~0, 4);havoc #t~mem1;~i~0 := 7 + ~i~0;~j~0 := 1 + ~j~0; {15548#false} is VALID [2018-11-23 12:12:06,765 INFO L273 TraceCheckUtils]: 79: Hoare triple {15548#false} assume !(~i~0 < 100000); {15548#false} is VALID [2018-11-23 12:12:06,765 INFO L273 TraceCheckUtils]: 80: Hoare triple {15548#false} ~i~0 := 1;~j~0 := 0; {15548#false} is VALID [2018-11-23 12:12:06,766 INFO L273 TraceCheckUtils]: 81: Hoare triple {15548#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 + 7 * ~j~0), 4); {15548#false} is VALID [2018-11-23 12:12:06,766 INFO L256 TraceCheckUtils]: 82: Hoare triple {15548#false} call __VERIFIER_assert((if #t~mem2 == #t~mem3 then 1 else 0)); {15548#false} is VALID [2018-11-23 12:12:06,766 INFO L273 TraceCheckUtils]: 83: Hoare triple {15548#false} ~cond := #in~cond; {15548#false} is VALID [2018-11-23 12:12:06,767 INFO L273 TraceCheckUtils]: 84: Hoare triple {15548#false} assume 0 == ~cond; {15548#false} is VALID [2018-11-23 12:12:06,767 INFO L273 TraceCheckUtils]: 85: Hoare triple {15548#false} assume !false; {15548#false} is VALID [2018-11-23 12:12:06,772 INFO L134 CoverageAnalysis]: Checked inductivity of 1848 backedges. 0 proven. 1770 refuted. 0 times theorem prover too weak. 78 trivial. 0 not checked. [2018-11-23 12:12:06,804 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:12:06,805 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [62, 62] total 63 [2018-11-23 12:12:06,805 INFO L78 Accepts]: Start accepts. Automaton has 63 states. Word has length 86 [2018-11-23 12:12:06,805 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:12:06,805 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 63 states. [2018-11-23 12:12:06,858 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:12:06,858 INFO L459 AbstractCegarLoop]: Interpolant automaton has 63 states [2018-11-23 12:12:06,859 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 63 interpolants. [2018-11-23 12:12:06,860 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1953, Invalid=1953, Unknown=0, NotChecked=0, Total=3906 [2018-11-23 12:12:06,860 INFO L87 Difference]: Start difference. First operand 90 states and 92 transitions. Second operand 63 states.