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_vector_difference_true-unreach-call_ground.i -------------------------------------------------------------------------------- This is Ultimate 0.1.23-61f4311 [2018-11-23 12:09:43,350 INFO L170 SettingsManager]: Resetting all preferences to default values... [2018-11-23 12:09:43,355 INFO L174 SettingsManager]: Resetting UltimateCore preferences to default values [2018-11-23 12:09:43,369 INFO L177 SettingsManager]: Ultimate Commandline Interface provides no preferences, ignoring... [2018-11-23 12:09:43,369 INFO L174 SettingsManager]: Resetting Boogie Preprocessor preferences to default values [2018-11-23 12:09:43,370 INFO L174 SettingsManager]: Resetting Boogie Procedure Inliner preferences to default values [2018-11-23 12:09:43,372 INFO L174 SettingsManager]: Resetting Abstract Interpretation preferences to default values [2018-11-23 12:09:43,374 INFO L174 SettingsManager]: Resetting LassoRanker preferences to default values [2018-11-23 12:09:43,376 INFO L174 SettingsManager]: Resetting Reaching Definitions preferences to default values [2018-11-23 12:09:43,376 INFO L174 SettingsManager]: Resetting SyntaxChecker preferences to default values [2018-11-23 12:09:43,377 INFO L177 SettingsManager]: Büchi Program Product provides no preferences, ignoring... [2018-11-23 12:09:43,378 INFO L174 SettingsManager]: Resetting LTL2Aut preferences to default values [2018-11-23 12:09:43,379 INFO L174 SettingsManager]: Resetting PEA to Boogie preferences to default values [2018-11-23 12:09:43,380 INFO L174 SettingsManager]: Resetting BlockEncodingV2 preferences to default values [2018-11-23 12:09:43,381 INFO L174 SettingsManager]: Resetting ChcToBoogie preferences to default values [2018-11-23 12:09:43,382 INFO L174 SettingsManager]: Resetting AutomataScriptInterpreter preferences to default values [2018-11-23 12:09:43,383 INFO L174 SettingsManager]: Resetting BuchiAutomizer preferences to default values [2018-11-23 12:09:43,385 INFO L174 SettingsManager]: Resetting CACSL2BoogieTranslator preferences to default values [2018-11-23 12:09:43,387 INFO L174 SettingsManager]: Resetting CodeCheck preferences to default values [2018-11-23 12:09:43,388 INFO L174 SettingsManager]: Resetting InvariantSynthesis preferences to default values [2018-11-23 12:09:43,390 INFO L174 SettingsManager]: Resetting RCFGBuilder preferences to default values [2018-11-23 12:09:43,391 INFO L174 SettingsManager]: Resetting TraceAbstraction preferences to default values [2018-11-23 12:09:43,394 INFO L177 SettingsManager]: TraceAbstractionConcurrent provides no preferences, ignoring... [2018-11-23 12:09:43,394 INFO L177 SettingsManager]: TraceAbstractionWithAFAs provides no preferences, ignoring... [2018-11-23 12:09:43,394 INFO L174 SettingsManager]: Resetting TreeAutomizer preferences to default values [2018-11-23 12:09:43,395 INFO L174 SettingsManager]: Resetting IcfgTransformer preferences to default values [2018-11-23 12:09:43,396 INFO L174 SettingsManager]: Resetting Boogie Printer preferences to default values [2018-11-23 12:09:43,397 INFO L174 SettingsManager]: Resetting ReqPrinter preferences to default values [2018-11-23 12:09:43,398 INFO L174 SettingsManager]: Resetting Witness Printer preferences to default values [2018-11-23 12:09:43,399 INFO L177 SettingsManager]: Boogie PL CUP Parser provides no preferences, ignoring... [2018-11-23 12:09:43,400 INFO L174 SettingsManager]: Resetting CDTParser preferences to default values [2018-11-23 12:09:43,400 INFO L177 SettingsManager]: AutomataScriptParser provides no preferences, ignoring... [2018-11-23 12:09:43,401 INFO L177 SettingsManager]: ReqParser provides no preferences, ignoring... [2018-11-23 12:09:43,401 INFO L174 SettingsManager]: Resetting SmtParser preferences to default values [2018-11-23 12:09:43,402 INFO L174 SettingsManager]: Resetting Witness Parser preferences to default values [2018-11-23 12:09:43,403 INFO L181 SettingsManager]: Finished resetting all preferences to default values... [2018-11-23 12:09:43,403 INFO L98 SettingsManager]: Beginning loading settings from /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/../../../trunk/examples/settings/default/automizer/svcomp-Reach-32bit-Automizer_Default.epf [2018-11-23 12:09:43,419 INFO L110 SettingsManager]: Loading preferences was successful [2018-11-23 12:09:43,420 INFO L112 SettingsManager]: Preferences different from defaults after loading the file: [2018-11-23 12:09:43,421 INFO L131 SettingsManager]: Preferences of Boogie Procedure Inliner differ from their defaults: [2018-11-23 12:09:43,421 INFO L133 SettingsManager]: * ... calls to implemented procedures=ONLY_FOR_CONCURRENT_PROGRAMS [2018-11-23 12:09:43,421 INFO L131 SettingsManager]: Preferences of BlockEncodingV2 differ from their defaults: [2018-11-23 12:09:43,422 INFO L133 SettingsManager]: * Create parallel compositions if possible=false [2018-11-23 12:09:43,422 INFO L133 SettingsManager]: * Use SBE=true [2018-11-23 12:09:43,422 INFO L131 SettingsManager]: Preferences of CACSL2BoogieTranslator differ from their defaults: [2018-11-23 12:09:43,422 INFO L133 SettingsManager]: * sizeof long=4 [2018-11-23 12:09:43,423 INFO L133 SettingsManager]: * Overapproximate operations on floating types=true [2018-11-23 12:09:43,423 INFO L133 SettingsManager]: * sizeof POINTER=4 [2018-11-23 12:09:43,423 INFO L133 SettingsManager]: * Check division by zero=IGNORE [2018-11-23 12:09:43,423 INFO L133 SettingsManager]: * Pointer to allocated memory at dereference=IGNORE [2018-11-23 12:09:43,423 INFO L133 SettingsManager]: * If two pointers are subtracted or compared they have the same base address=IGNORE [2018-11-23 12:09:43,424 INFO L133 SettingsManager]: * Check array bounds for arrays that are off heap=IGNORE [2018-11-23 12:09:43,424 INFO L133 SettingsManager]: * sizeof long double=12 [2018-11-23 12:09:43,424 INFO L133 SettingsManager]: * Check if freed pointer was valid=false [2018-11-23 12:09:43,424 INFO L133 SettingsManager]: * Use constant arrays=true [2018-11-23 12:09:43,424 INFO L133 SettingsManager]: * Pointer base address is valid at dereference=IGNORE [2018-11-23 12:09:43,425 INFO L131 SettingsManager]: Preferences of RCFGBuilder differ from their defaults: [2018-11-23 12:09:43,425 INFO L133 SettingsManager]: * Size of a code block=SequenceOfStatements [2018-11-23 12:09:43,425 INFO L133 SettingsManager]: * To the following directory=./dump/ [2018-11-23 12:09:43,425 INFO L133 SettingsManager]: * SMT solver=External_DefaultMode [2018-11-23 12:09:43,425 INFO L133 SettingsManager]: * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in -t:2000 [2018-11-23 12:09:43,426 INFO L131 SettingsManager]: Preferences of TraceAbstraction differ from their defaults: [2018-11-23 12:09:43,426 INFO L133 SettingsManager]: * Compute Interpolants along a Counterexample=FPandBP [2018-11-23 12:09:43,426 INFO L133 SettingsManager]: * Positions where we compute the Hoare Annotation=LoopsAndPotentialCycles [2018-11-23 12:09:43,426 INFO L133 SettingsManager]: * Trace refinement strategy=CAMEL [2018-11-23 12:09:43,427 INFO L133 SettingsManager]: * SMT solver=External_ModelsAndUnsatCoreMode [2018-11-23 12:09:43,427 INFO L133 SettingsManager]: * Command for external solver=z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in [2018-11-23 12:09:43,427 INFO L133 SettingsManager]: * Compute Hoare Annotation of negated interpolant automaton, abstraction and CFG=true [2018-11-23 12:09:43,478 INFO L81 nceAwareModelManager]: Repository-Root is: /tmp [2018-11-23 12:09:43,497 INFO L258 ainManager$Toolchain]: [Toolchain 1]: Applicable parser(s) successfully (re)initialized [2018-11-23 12:09:43,502 INFO L214 ainManager$Toolchain]: [Toolchain 1]: Toolchain selected. [2018-11-23 12:09:43,504 INFO L271 PluginConnector]: Initializing CDTParser... [2018-11-23 12:09:43,504 INFO L276 PluginConnector]: CDTParser initialized [2018-11-23 12:09:43,506 INFO L418 ainManager$Toolchain]: [Toolchain 1]: Parsing single file: /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/../../../trunk/examples/svcomp/array-examples/standard_vector_difference_true-unreach-call_ground.i [2018-11-23 12:09:43,577 INFO L221 CDTParser]: Created temporary CDT project at /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/aba41c784/4d9828ae897845c7843266c27c31dc09/FLAGb036a35d9 [2018-11-23 12:09:44,070 INFO L307 CDTParser]: Found 1 translation units. [2018-11-23 12:09:44,070 INFO L161 CDTParser]: Scanning /storage/repos/ultimate/trunk/examples/svcomp/array-examples/standard_vector_difference_true-unreach-call_ground.i [2018-11-23 12:09:44,076 INFO L355 CDTParser]: About to delete temporary CDT project at /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/aba41c784/4d9828ae897845c7843266c27c31dc09/FLAGb036a35d9 [2018-11-23 12:09:44,414 INFO L363 CDTParser]: Successfully deleted /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/data/aba41c784/4d9828ae897845c7843266c27c31dc09 [2018-11-23 12:09:44,425 INFO L296 ainManager$Toolchain]: ####################### [Toolchain 1] ####################### [2018-11-23 12:09:44,427 INFO L131 ToolchainWalker]: Walking toolchain with 6 elements. [2018-11-23 12:09:44,428 INFO L113 PluginConnector]: ------------------------CACSL2BoogieTranslator---------------------------- [2018-11-23 12:09:44,428 INFO L271 PluginConnector]: Initializing CACSL2BoogieTranslator... [2018-11-23 12:09:44,432 INFO L276 PluginConnector]: CACSL2BoogieTranslator initialized [2018-11-23 12:09:44,434 INFO L185 PluginConnector]: Executing the observer ACSLObjectContainerObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 23.11 12:09:44" (1/1) ... [2018-11-23 12:09:44,437 INFO L205 PluginConnector]: Invalid model from CACSL2BoogieTranslator for observer de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator.ACSLObjectContainerObserver@4d22123d and model type de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:44, skipping insertion in model container [2018-11-23 12:09:44,437 INFO L185 PluginConnector]: Executing the observer CACSL2BoogieTranslatorObserver from plugin CACSL2BoogieTranslator for "CDTParser AST 23.11 12:09:44" (1/1) ... [2018-11-23 12:09:44,447 INFO L145 MainTranslator]: Starting translation in SV-COMP mode [2018-11-23 12:09:44,473 INFO L176 MainTranslator]: Built tables and reachable declarations [2018-11-23 12:09:44,690 INFO L201 PostProcessor]: Analyzing one entry point: main [2018-11-23 12:09:44,697 INFO L191 MainTranslator]: Completed pre-run [2018-11-23 12:09:44,723 INFO L201 PostProcessor]: Analyzing one entry point: main [2018-11-23 12:09:44,746 INFO L195 MainTranslator]: Completed translation [2018-11-23 12:09:44,747 INFO L202 PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:44 WrapperNode [2018-11-23 12:09:44,747 INFO L132 PluginConnector]: ------------------------ END CACSL2BoogieTranslator---------------------------- [2018-11-23 12:09:44,748 INFO L113 PluginConnector]: ------------------------Boogie Procedure Inliner---------------------------- [2018-11-23 12:09:44,748 INFO L271 PluginConnector]: Initializing Boogie Procedure Inliner... [2018-11-23 12:09:44,748 INFO L276 PluginConnector]: Boogie Procedure Inliner initialized [2018-11-23 12:09:44,755 INFO L185 PluginConnector]: Executing the observer TypeChecker from plugin Boogie Procedure Inliner for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:44" (1/1) ... [2018-11-23 12:09:44,764 INFO L185 PluginConnector]: Executing the observer Inliner from plugin Boogie Procedure Inliner for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:44" (1/1) ... [2018-11-23 12:09:44,773 INFO L132 PluginConnector]: ------------------------ END Boogie Procedure Inliner---------------------------- [2018-11-23 12:09:44,773 INFO L113 PluginConnector]: ------------------------Boogie Preprocessor---------------------------- [2018-11-23 12:09:44,774 INFO L271 PluginConnector]: Initializing Boogie Preprocessor... [2018-11-23 12:09:44,774 INFO L276 PluginConnector]: Boogie Preprocessor initialized [2018-11-23 12:09:44,784 INFO L185 PluginConnector]: Executing the observer EnsureBoogieModelObserver from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:44" (1/1) ... [2018-11-23 12:09:44,784 INFO L185 PluginConnector]: Executing the observer TypeChecker from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:44" (1/1) ... [2018-11-23 12:09:44,786 INFO L185 PluginConnector]: Executing the observer ConstExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:44" (1/1) ... [2018-11-23 12:09:44,786 INFO L185 PluginConnector]: Executing the observer StructExpander from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:44" (1/1) ... [2018-11-23 12:09:44,797 INFO L185 PluginConnector]: Executing the observer UnstructureCode from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:44" (1/1) ... [2018-11-23 12:09:44,805 INFO L185 PluginConnector]: Executing the observer FunctionInliner from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:44" (1/1) ... [2018-11-23 12:09:44,807 INFO L185 PluginConnector]: Executing the observer BoogieSymbolTableConstructor from plugin Boogie Preprocessor for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:44" (1/1) ... [2018-11-23 12:09:44,814 INFO L132 PluginConnector]: ------------------------ END Boogie Preprocessor---------------------------- [2018-11-23 12:09:44,814 INFO L113 PluginConnector]: ------------------------RCFGBuilder---------------------------- [2018-11-23 12:09:44,815 INFO L271 PluginConnector]: Initializing RCFGBuilder... [2018-11-23 12:09:44,815 INFO L276 PluginConnector]: RCFGBuilder initialized [2018-11-23 12:09:44,816 INFO L185 PluginConnector]: Executing the observer RCFGBuilderObserver from plugin RCFGBuilder for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:44" (1/1) ... No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 1 with z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in -t:2000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 1 with z3 SMTLIB2_COMPLIANT=true -memory:2024 -smt2 -in -t:2000 [2018-11-23 12:09:44,951 INFO L130 BoogieDeclarations]: Found specification of procedure write~int [2018-11-23 12:09:44,951 INFO L130 BoogieDeclarations]: Found specification of procedure ULTIMATE.init [2018-11-23 12:09:44,951 INFO L138 BoogieDeclarations]: Found implementation of procedure ULTIMATE.init [2018-11-23 12:09:44,951 INFO L130 BoogieDeclarations]: Found specification of procedure #Ultimate.alloc [2018-11-23 12:09:44,951 INFO L130 BoogieDeclarations]: Found specification of procedure ULTIMATE.start [2018-11-23 12:09:44,952 INFO L138 BoogieDeclarations]: Found implementation of procedure ULTIMATE.start [2018-11-23 12:09:44,952 INFO L130 BoogieDeclarations]: Found specification of procedure read~int [2018-11-23 12:09:44,952 INFO L130 BoogieDeclarations]: Found specification of procedure main [2018-11-23 12:09:44,952 INFO L138 BoogieDeclarations]: Found implementation of procedure main [2018-11-23 12:09:44,952 INFO L130 BoogieDeclarations]: Found specification of procedure __VERIFIER_assert [2018-11-23 12:09:44,952 INFO L138 BoogieDeclarations]: Found implementation of procedure __VERIFIER_assert [2018-11-23 12:09:44,952 INFO L130 BoogieDeclarations]: Found specification of procedure ULTIMATE.dealloc [2018-11-23 12:09:45,454 INFO L275 CfgBuilder]: Using the 1 location(s) as analysis (start of procedure ULTIMATE.start) [2018-11-23 12:09:45,455 INFO L280 CfgBuilder]: Removed 2 assue(true) statements. [2018-11-23 12:09:45,455 INFO L202 PluginConnector]: Adding new model de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 23.11 12:09:45 BoogieIcfgContainer [2018-11-23 12:09:45,455 INFO L132 PluginConnector]: ------------------------ END RCFGBuilder---------------------------- [2018-11-23 12:09:45,456 INFO L113 PluginConnector]: ------------------------TraceAbstraction---------------------------- [2018-11-23 12:09:45,457 INFO L271 PluginConnector]: Initializing TraceAbstraction... [2018-11-23 12:09:45,460 INFO L276 PluginConnector]: TraceAbstraction initialized [2018-11-23 12:09:45,460 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "CDTParser AST 23.11 12:09:44" (1/3) ... [2018-11-23 12:09:45,461 INFO L205 PluginConnector]: Invalid model from TraceAbstraction for observer de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionObserver@6e4d230e and model type de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction AST 23.11 12:09:45, skipping insertion in model container [2018-11-23 12:09:45,462 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "de.uni_freiburg.informatik.ultimate.plugins.generator.cacsl2boogietranslator AST 23.11 12:09:44" (2/3) ... [2018-11-23 12:09:45,462 INFO L205 PluginConnector]: Invalid model from TraceAbstraction for observer de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction.TraceAbstractionObserver@6e4d230e and model type de.uni_freiburg.informatik.ultimate.plugins.generator.traceabstraction AST 23.11 12:09:45, skipping insertion in model container [2018-11-23 12:09:45,462 INFO L185 PluginConnector]: Executing the observer TraceAbstractionObserver from plugin TraceAbstraction for "de.uni_freiburg.informatik.ultimate.plugins.generator.rcfgbuilder CFG 23.11 12:09:45" (3/3) ... [2018-11-23 12:09:45,464 INFO L112 eAbstractionObserver]: Analyzing ICFG standard_vector_difference_true-unreach-call_ground.i [2018-11-23 12:09:45,475 INFO L156 ceAbstractionStarter]: Automizer settings: Hoare:true NWA Interpolation:FPandBP Determinization: PREDICATE_ABSTRACTION [2018-11-23 12:09:45,483 INFO L168 ceAbstractionStarter]: Appying trace abstraction to program that has 1 error locations. [2018-11-23 12:09:45,502 INFO L257 AbstractCegarLoop]: Starting to check reachability of 1 error locations. [2018-11-23 12:09:45,536 INFO L133 ementStrategyFactory]: Using default assertion order modulation [2018-11-23 12:09:45,537 INFO L382 AbstractCegarLoop]: Interprodecural is true [2018-11-23 12:09:45,538 INFO L383 AbstractCegarLoop]: Hoare is true [2018-11-23 12:09:45,538 INFO L384 AbstractCegarLoop]: Compute interpolants for FPandBP [2018-11-23 12:09:45,539 INFO L385 AbstractCegarLoop]: Backedges is STRAIGHT_LINE [2018-11-23 12:09:45,539 INFO L386 AbstractCegarLoop]: Determinization is PREDICATE_ABSTRACTION [2018-11-23 12:09:45,539 INFO L387 AbstractCegarLoop]: Difference is false [2018-11-23 12:09:45,540 INFO L388 AbstractCegarLoop]: Minimize is MINIMIZE_SEVPA [2018-11-23 12:09:45,540 INFO L393 AbstractCegarLoop]: ======== Iteration 0==of CEGAR loop == AllErrorsAtOnce======== [2018-11-23 12:09:45,559 INFO L276 IsEmpty]: Start isEmpty. Operand 23 states. [2018-11-23 12:09:45,565 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 14 [2018-11-23 12:09:45,566 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:45,567 INFO L402 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:45,569 INFO L423 AbstractCegarLoop]: === Iteration 1 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:45,575 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:45,575 INFO L82 PathProgramCache]: Analyzing trace with hash -441053002, now seen corresponding path program 1 times [2018-11-23 12:09:45,577 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:45,578 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:45,623 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:45,624 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:45,624 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:45,663 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:45,735 INFO L256 TraceCheckUtils]: 0: Hoare triple {26#true} call ULTIMATE.init(); {26#true} is VALID [2018-11-23 12:09:45,739 INFO L273 TraceCheckUtils]: 1: Hoare triple {26#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {26#true} is VALID [2018-11-23 12:09:45,740 INFO L273 TraceCheckUtils]: 2: Hoare triple {26#true} assume true; {26#true} is VALID [2018-11-23 12:09:45,741 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {26#true} {26#true} #48#return; {26#true} is VALID [2018-11-23 12:09:45,743 INFO L256 TraceCheckUtils]: 4: Hoare triple {26#true} call #t~ret6 := main(); {26#true} is VALID [2018-11-23 12:09:45,743 INFO L273 TraceCheckUtils]: 5: Hoare triple {26#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {26#true} is VALID [2018-11-23 12:09:45,753 INFO L273 TraceCheckUtils]: 6: Hoare triple {26#true} assume !true; {27#false} is VALID [2018-11-23 12:09:45,754 INFO L273 TraceCheckUtils]: 7: Hoare triple {27#false} havoc ~x~0;~x~0 := 0; {27#false} is VALID [2018-11-23 12:09:45,754 INFO L273 TraceCheckUtils]: 8: Hoare triple {27#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {27#false} is VALID [2018-11-23 12:09:45,754 INFO L256 TraceCheckUtils]: 9: Hoare triple {27#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {27#false} is VALID [2018-11-23 12:09:45,755 INFO L273 TraceCheckUtils]: 10: Hoare triple {27#false} ~cond := #in~cond; {27#false} is VALID [2018-11-23 12:09:45,755 INFO L273 TraceCheckUtils]: 11: Hoare triple {27#false} assume 0 == ~cond; {27#false} is VALID [2018-11-23 12:09:45,756 INFO L273 TraceCheckUtils]: 12: Hoare triple {27#false} assume !false; {27#false} is VALID [2018-11-23 12:09:45,758 INFO L134 CoverageAnalysis]: Checked inductivity of 0 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:45,761 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 12:09:45,761 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [2] imperfect sequences [] total 2 [2018-11-23 12:09:45,765 INFO L78 Accepts]: Start accepts. Automaton has 2 states. Word has length 13 [2018-11-23 12:09:45,769 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:45,773 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 2 states. [2018-11-23 12:09:45,851 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 13 edges. 13 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:45,852 INFO L459 AbstractCegarLoop]: Interpolant automaton has 2 states [2018-11-23 12:09:45,861 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 2 interpolants. [2018-11-23 12:09:45,861 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=1, Invalid=1, Unknown=0, NotChecked=0, Total=2 [2018-11-23 12:09:45,864 INFO L87 Difference]: Start difference. First operand 23 states. Second operand 2 states. [2018-11-23 12:09:46,066 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:46,066 INFO L93 Difference]: Finished difference Result 39 states and 46 transitions. [2018-11-23 12:09:46,066 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 2 states. [2018-11-23 12:09:46,066 INFO L78 Accepts]: Start accepts. Automaton has 2 states. Word has length 13 [2018-11-23 12:09:46,067 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:46,068 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 2 states. [2018-11-23 12:09:46,078 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 2 states to 2 states and 46 transitions. [2018-11-23 12:09:46,079 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 2 states. [2018-11-23 12:09:46,084 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 2 states to 2 states and 46 transitions. [2018-11-23 12:09:46,084 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 2 states and 46 transitions. [2018-11-23 12:09:46,328 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 46 edges. 46 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:46,343 INFO L225 Difference]: With dead ends: 39 [2018-11-23 12:09:46,343 INFO L226 Difference]: Without dead ends: 18 [2018-11-23 12:09:46,351 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 2 GetRequests, 2 SyntacticMatches, 0 SemanticMatches, 0 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=1, Invalid=1, Unknown=0, NotChecked=0, Total=2 [2018-11-23 12:09:46,371 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 18 states. [2018-11-23 12:09:46,494 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 18 to 18. [2018-11-23 12:09:46,494 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:46,495 INFO L82 GeneralOperation]: Start isEquivalent. First operand 18 states. Second operand 18 states. [2018-11-23 12:09:46,496 INFO L74 IsIncluded]: Start isIncluded. First operand 18 states. Second operand 18 states. [2018-11-23 12:09:46,496 INFO L87 Difference]: Start difference. First operand 18 states. Second operand 18 states. [2018-11-23 12:09:46,499 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:46,499 INFO L93 Difference]: Finished difference Result 18 states and 19 transitions. [2018-11-23 12:09:46,501 INFO L276 IsEmpty]: Start isEmpty. Operand 18 states and 19 transitions. [2018-11-23 12:09:46,502 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:46,502 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:46,502 INFO L74 IsIncluded]: Start isIncluded. First operand 18 states. Second operand 18 states. [2018-11-23 12:09:46,502 INFO L87 Difference]: Start difference. First operand 18 states. Second operand 18 states. [2018-11-23 12:09:46,506 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:46,506 INFO L93 Difference]: Finished difference Result 18 states and 19 transitions. [2018-11-23 12:09:46,509 INFO L276 IsEmpty]: Start isEmpty. Operand 18 states and 19 transitions. [2018-11-23 12:09:46,509 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:46,509 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:46,509 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:46,510 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:46,510 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 18 states. [2018-11-23 12:09:46,514 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 18 states to 18 states and 19 transitions. [2018-11-23 12:09:46,517 INFO L78 Accepts]: Start accepts. Automaton has 18 states and 19 transitions. Word has length 13 [2018-11-23 12:09:46,517 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:46,517 INFO L480 AbstractCegarLoop]: Abstraction has 18 states and 19 transitions. [2018-11-23 12:09:46,517 INFO L481 AbstractCegarLoop]: Interpolant automaton has 2 states. [2018-11-23 12:09:46,518 INFO L276 IsEmpty]: Start isEmpty. Operand 18 states and 19 transitions. [2018-11-23 12:09:46,518 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 14 [2018-11-23 12:09:46,518 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:46,519 INFO L402 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:46,520 INFO L423 AbstractCegarLoop]: === Iteration 2 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:46,520 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:46,520 INFO L82 PathProgramCache]: Analyzing trace with hash 303899570, now seen corresponding path program 1 times [2018-11-23 12:09:46,520 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:46,520 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:46,523 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:46,523 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:46,523 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:46,583 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:46,692 INFO L256 TraceCheckUtils]: 0: Hoare triple {142#true} call ULTIMATE.init(); {142#true} is VALID [2018-11-23 12:09:46,692 INFO L273 TraceCheckUtils]: 1: Hoare triple {142#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {142#true} is VALID [2018-11-23 12:09:46,693 INFO L273 TraceCheckUtils]: 2: Hoare triple {142#true} assume true; {142#true} is VALID [2018-11-23 12:09:46,693 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {142#true} {142#true} #48#return; {142#true} is VALID [2018-11-23 12:09:46,693 INFO L256 TraceCheckUtils]: 4: Hoare triple {142#true} call #t~ret6 := main(); {142#true} is VALID [2018-11-23 12:09:46,702 INFO L273 TraceCheckUtils]: 5: Hoare triple {142#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {144#(= main_~i~0 0)} is VALID [2018-11-23 12:09:46,715 INFO L273 TraceCheckUtils]: 6: Hoare triple {144#(= main_~i~0 0)} assume !(~i~0 < 100000); {143#false} is VALID [2018-11-23 12:09:46,716 INFO L273 TraceCheckUtils]: 7: Hoare triple {143#false} havoc ~x~0;~x~0 := 0; {143#false} is VALID [2018-11-23 12:09:46,716 INFO L273 TraceCheckUtils]: 8: Hoare triple {143#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {143#false} is VALID [2018-11-23 12:09:46,716 INFO L256 TraceCheckUtils]: 9: Hoare triple {143#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {143#false} is VALID [2018-11-23 12:09:46,717 INFO L273 TraceCheckUtils]: 10: Hoare triple {143#false} ~cond := #in~cond; {143#false} is VALID [2018-11-23 12:09:46,717 INFO L273 TraceCheckUtils]: 11: Hoare triple {143#false} assume 0 == ~cond; {143#false} is VALID [2018-11-23 12:09:46,717 INFO L273 TraceCheckUtils]: 12: Hoare triple {143#false} assume !false; {143#false} is VALID [2018-11-23 12:09:46,718 INFO L134 CoverageAnalysis]: Checked inductivity of 0 backedges. 0 proven. 0 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:46,719 INFO L312 seRefinementStrategy]: Constructing automaton from 1 perfect and 0 imperfect interpolant sequences. [2018-11-23 12:09:46,719 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [3] imperfect sequences [] total 3 [2018-11-23 12:09:46,720 INFO L78 Accepts]: Start accepts. Automaton has 3 states. Word has length 13 [2018-11-23 12:09:46,721 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:46,721 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 3 states. [2018-11-23 12:09:46,799 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 13 edges. 13 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:46,799 INFO L459 AbstractCegarLoop]: Interpolant automaton has 3 states [2018-11-23 12:09:46,799 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 3 interpolants. [2018-11-23 12:09:46,800 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=3, Invalid=3, Unknown=0, NotChecked=0, Total=6 [2018-11-23 12:09:46,800 INFO L87 Difference]: Start difference. First operand 18 states and 19 transitions. Second operand 3 states. [2018-11-23 12:09:47,016 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:47,016 INFO L93 Difference]: Finished difference Result 30 states and 32 transitions. [2018-11-23 12:09:47,016 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 3 states. [2018-11-23 12:09:47,016 INFO L78 Accepts]: Start accepts. Automaton has 3 states. Word has length 13 [2018-11-23 12:09:47,017 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:47,017 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 3 states. [2018-11-23 12:09:47,020 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 3 states to 3 states and 32 transitions. [2018-11-23 12:09:47,021 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 3 states. [2018-11-23 12:09:47,026 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 3 states to 3 states and 32 transitions. [2018-11-23 12:09:47,027 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 3 states and 32 transitions. [2018-11-23 12:09:47,127 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 32 edges. 32 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:47,130 INFO L225 Difference]: With dead ends: 30 [2018-11-23 12:09:47,130 INFO L226 Difference]: Without dead ends: 19 [2018-11-23 12:09:47,131 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 3 GetRequests, 2 SyntacticMatches, 0 SemanticMatches, 1 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=3, Invalid=3, Unknown=0, NotChecked=0, Total=6 [2018-11-23 12:09:47,132 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 19 states. [2018-11-23 12:09:47,146 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 19 to 19. [2018-11-23 12:09:47,146 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:47,146 INFO L82 GeneralOperation]: Start isEquivalent. First operand 19 states. Second operand 19 states. [2018-11-23 12:09:47,146 INFO L74 IsIncluded]: Start isIncluded. First operand 19 states. Second operand 19 states. [2018-11-23 12:09:47,147 INFO L87 Difference]: Start difference. First operand 19 states. Second operand 19 states. [2018-11-23 12:09:47,148 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:47,148 INFO L93 Difference]: Finished difference Result 19 states and 20 transitions. [2018-11-23 12:09:47,148 INFO L276 IsEmpty]: Start isEmpty. Operand 19 states and 20 transitions. [2018-11-23 12:09:47,149 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:47,149 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:47,149 INFO L74 IsIncluded]: Start isIncluded. First operand 19 states. Second operand 19 states. [2018-11-23 12:09:47,149 INFO L87 Difference]: Start difference. First operand 19 states. Second operand 19 states. [2018-11-23 12:09:47,151 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:47,151 INFO L93 Difference]: Finished difference Result 19 states and 20 transitions. [2018-11-23 12:09:47,152 INFO L276 IsEmpty]: Start isEmpty. Operand 19 states and 20 transitions. [2018-11-23 12:09:47,152 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:47,152 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:47,152 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:47,153 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:47,153 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 19 states. [2018-11-23 12:09:47,155 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 19 states to 19 states and 20 transitions. [2018-11-23 12:09:47,155 INFO L78 Accepts]: Start accepts. Automaton has 19 states and 20 transitions. Word has length 13 [2018-11-23 12:09:47,155 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:47,155 INFO L480 AbstractCegarLoop]: Abstraction has 19 states and 20 transitions. [2018-11-23 12:09:47,155 INFO L481 AbstractCegarLoop]: Interpolant automaton has 3 states. [2018-11-23 12:09:47,156 INFO L276 IsEmpty]: Start isEmpty. Operand 19 states and 20 transitions. [2018-11-23 12:09:47,156 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 15 [2018-11-23 12:09:47,156 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:47,157 INFO L402 BasicCegarLoop]: trace histogram [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:47,157 INFO L423 AbstractCegarLoop]: === Iteration 3 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:47,157 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:47,157 INFO L82 PathProgramCache]: Analyzing trace with hash -1260126610, now seen corresponding path program 1 times [2018-11-23 12:09:47,158 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:47,158 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:47,159 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:47,159 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:47,159 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:47,201 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:47,282 INFO L256 TraceCheckUtils]: 0: Hoare triple {255#true} call ULTIMATE.init(); {255#true} is VALID [2018-11-23 12:09:47,282 INFO L273 TraceCheckUtils]: 1: Hoare triple {255#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {255#true} is VALID [2018-11-23 12:09:47,283 INFO L273 TraceCheckUtils]: 2: Hoare triple {255#true} assume true; {255#true} is VALID [2018-11-23 12:09:47,283 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {255#true} {255#true} #48#return; {255#true} is VALID [2018-11-23 12:09:47,284 INFO L256 TraceCheckUtils]: 4: Hoare triple {255#true} call #t~ret6 := main(); {255#true} is VALID [2018-11-23 12:09:47,285 INFO L273 TraceCheckUtils]: 5: Hoare triple {255#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {257#(= main_~i~0 0)} is VALID [2018-11-23 12:09:47,288 INFO L273 TraceCheckUtils]: 6: Hoare triple {257#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {258#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:47,289 INFO L273 TraceCheckUtils]: 7: Hoare triple {258#(<= main_~i~0 1)} assume !(~i~0 < 100000); {256#false} is VALID [2018-11-23 12:09:47,289 INFO L273 TraceCheckUtils]: 8: Hoare triple {256#false} havoc ~x~0;~x~0 := 0; {256#false} is VALID [2018-11-23 12:09:47,290 INFO L273 TraceCheckUtils]: 9: Hoare triple {256#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {256#false} is VALID [2018-11-23 12:09:47,290 INFO L256 TraceCheckUtils]: 10: Hoare triple {256#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {256#false} is VALID [2018-11-23 12:09:47,290 INFO L273 TraceCheckUtils]: 11: Hoare triple {256#false} ~cond := #in~cond; {256#false} is VALID [2018-11-23 12:09:47,290 INFO L273 TraceCheckUtils]: 12: Hoare triple {256#false} assume 0 == ~cond; {256#false} is VALID [2018-11-23 12:09:47,291 INFO L273 TraceCheckUtils]: 13: Hoare triple {256#false} assume !false; {256#false} is VALID [2018-11-23 12:09:47,293 INFO L134 CoverageAnalysis]: Checked inductivity of 1 backedges. 0 proven. 1 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:47,293 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:47,293 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 2 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 2 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:47,304 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:47,325 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:47,350 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:47,355 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:47,893 INFO L256 TraceCheckUtils]: 0: Hoare triple {255#true} call ULTIMATE.init(); {255#true} is VALID [2018-11-23 12:09:47,893 INFO L273 TraceCheckUtils]: 1: Hoare triple {255#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {255#true} is VALID [2018-11-23 12:09:47,894 INFO L273 TraceCheckUtils]: 2: Hoare triple {255#true} assume true; {255#true} is VALID [2018-11-23 12:09:47,894 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {255#true} {255#true} #48#return; {255#true} is VALID [2018-11-23 12:09:47,894 INFO L256 TraceCheckUtils]: 4: Hoare triple {255#true} call #t~ret6 := main(); {255#true} is VALID [2018-11-23 12:09:47,906 INFO L273 TraceCheckUtils]: 5: Hoare triple {255#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {277#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:47,909 INFO L273 TraceCheckUtils]: 6: Hoare triple {277#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {258#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:47,912 INFO L273 TraceCheckUtils]: 7: Hoare triple {258#(<= main_~i~0 1)} assume !(~i~0 < 100000); {256#false} is VALID [2018-11-23 12:09:47,913 INFO L273 TraceCheckUtils]: 8: Hoare triple {256#false} havoc ~x~0;~x~0 := 0; {256#false} is VALID [2018-11-23 12:09:47,913 INFO L273 TraceCheckUtils]: 9: Hoare triple {256#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {256#false} is VALID [2018-11-23 12:09:47,914 INFO L256 TraceCheckUtils]: 10: Hoare triple {256#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {256#false} is VALID [2018-11-23 12:09:47,914 INFO L273 TraceCheckUtils]: 11: Hoare triple {256#false} ~cond := #in~cond; {256#false} is VALID [2018-11-23 12:09:47,914 INFO L273 TraceCheckUtils]: 12: Hoare triple {256#false} assume 0 == ~cond; {256#false} is VALID [2018-11-23 12:09:47,915 INFO L273 TraceCheckUtils]: 13: Hoare triple {256#false} assume !false; {256#false} is VALID [2018-11-23 12:09:47,916 INFO L134 CoverageAnalysis]: Checked inductivity of 1 backedges. 0 proven. 1 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:47,937 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:47,937 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [4, 4] total 5 [2018-11-23 12:09:47,937 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 14 [2018-11-23 12:09:47,938 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:47,938 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states. [2018-11-23 12:09:47,973 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 16 edges. 16 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:47,973 INFO L459 AbstractCegarLoop]: Interpolant automaton has 5 states [2018-11-23 12:09:47,974 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 5 interpolants. [2018-11-23 12:09:47,974 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=10, Invalid=10, Unknown=0, NotChecked=0, Total=20 [2018-11-23 12:09:47,974 INFO L87 Difference]: Start difference. First operand 19 states and 20 transitions. Second operand 5 states. [2018-11-23 12:09:48,242 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:48,242 INFO L93 Difference]: Finished difference Result 31 states and 33 transitions. [2018-11-23 12:09:48,242 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 4 states. [2018-11-23 12:09:48,242 INFO L78 Accepts]: Start accepts. Automaton has 5 states. Word has length 14 [2018-11-23 12:09:48,243 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:48,243 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 12:09:48,245 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 4 states to 4 states and 33 transitions. [2018-11-23 12:09:48,245 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 5 states. [2018-11-23 12:09:48,248 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 4 states to 4 states and 33 transitions. [2018-11-23 12:09:48,248 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 4 states and 33 transitions. [2018-11-23 12:09:48,326 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:48,327 INFO L225 Difference]: With dead ends: 31 [2018-11-23 12:09:48,327 INFO L226 Difference]: Without dead ends: 20 [2018-11-23 12:09:48,328 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 17 GetRequests, 14 SyntacticMatches, 0 SemanticMatches, 3 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 0 ImplicationChecksByTransitivity, 0.1s TimeCoverageRelationStatistics Valid=10, Invalid=10, Unknown=0, NotChecked=0, Total=20 [2018-11-23 12:09:48,328 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 20 states. [2018-11-23 12:09:48,341 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 20 to 20. [2018-11-23 12:09:48,341 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:48,341 INFO L82 GeneralOperation]: Start isEquivalent. First operand 20 states. Second operand 20 states. [2018-11-23 12:09:48,341 INFO L74 IsIncluded]: Start isIncluded. First operand 20 states. Second operand 20 states. [2018-11-23 12:09:48,342 INFO L87 Difference]: Start difference. First operand 20 states. Second operand 20 states. [2018-11-23 12:09:48,344 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:48,344 INFO L93 Difference]: Finished difference Result 20 states and 21 transitions. [2018-11-23 12:09:48,344 INFO L276 IsEmpty]: Start isEmpty. Operand 20 states and 21 transitions. [2018-11-23 12:09:48,344 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:48,345 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:48,345 INFO L74 IsIncluded]: Start isIncluded. First operand 20 states. Second operand 20 states. [2018-11-23 12:09:48,345 INFO L87 Difference]: Start difference. First operand 20 states. Second operand 20 states. [2018-11-23 12:09:48,347 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:48,347 INFO L93 Difference]: Finished difference Result 20 states and 21 transitions. [2018-11-23 12:09:48,347 INFO L276 IsEmpty]: Start isEmpty. Operand 20 states and 21 transitions. [2018-11-23 12:09:48,348 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:48,348 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:48,348 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:48,348 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:48,348 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 20 states. [2018-11-23 12:09:48,350 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 20 states to 20 states and 21 transitions. [2018-11-23 12:09:48,350 INFO L78 Accepts]: Start accepts. Automaton has 20 states and 21 transitions. Word has length 14 [2018-11-23 12:09:48,350 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:48,350 INFO L480 AbstractCegarLoop]: Abstraction has 20 states and 21 transitions. [2018-11-23 12:09:48,351 INFO L481 AbstractCegarLoop]: Interpolant automaton has 5 states. [2018-11-23 12:09:48,351 INFO L276 IsEmpty]: Start isEmpty. Operand 20 states and 21 transitions. [2018-11-23 12:09:48,351 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 16 [2018-11-23 12:09:48,351 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:48,352 INFO L402 BasicCegarLoop]: trace histogram [2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:48,352 INFO L423 AbstractCegarLoop]: === Iteration 4 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:48,352 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:48,352 INFO L82 PathProgramCache]: Analyzing trace with hash 1794669362, now seen corresponding path program 2 times [2018-11-23 12:09:48,353 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:48,353 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:48,354 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:48,354 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:48,354 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:48,371 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:48,449 INFO L256 TraceCheckUtils]: 0: Hoare triple {415#true} call ULTIMATE.init(); {415#true} is VALID [2018-11-23 12:09:48,450 INFO L273 TraceCheckUtils]: 1: Hoare triple {415#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {415#true} is VALID [2018-11-23 12:09:48,450 INFO L273 TraceCheckUtils]: 2: Hoare triple {415#true} assume true; {415#true} is VALID [2018-11-23 12:09:48,450 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {415#true} {415#true} #48#return; {415#true} is VALID [2018-11-23 12:09:48,450 INFO L256 TraceCheckUtils]: 4: Hoare triple {415#true} call #t~ret6 := main(); {415#true} is VALID [2018-11-23 12:09:48,455 INFO L273 TraceCheckUtils]: 5: Hoare triple {415#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {417#(= main_~i~0 0)} is VALID [2018-11-23 12:09:48,456 INFO L273 TraceCheckUtils]: 6: Hoare triple {417#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {418#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:48,473 INFO L273 TraceCheckUtils]: 7: Hoare triple {418#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {419#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:48,478 INFO L273 TraceCheckUtils]: 8: Hoare triple {419#(<= main_~i~0 2)} assume !(~i~0 < 100000); {416#false} is VALID [2018-11-23 12:09:48,478 INFO L273 TraceCheckUtils]: 9: Hoare triple {416#false} havoc ~x~0;~x~0 := 0; {416#false} is VALID [2018-11-23 12:09:48,478 INFO L273 TraceCheckUtils]: 10: Hoare triple {416#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {416#false} is VALID [2018-11-23 12:09:48,479 INFO L256 TraceCheckUtils]: 11: Hoare triple {416#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {416#false} is VALID [2018-11-23 12:09:48,479 INFO L273 TraceCheckUtils]: 12: Hoare triple {416#false} ~cond := #in~cond; {416#false} is VALID [2018-11-23 12:09:48,480 INFO L273 TraceCheckUtils]: 13: Hoare triple {416#false} assume 0 == ~cond; {416#false} is VALID [2018-11-23 12:09:48,480 INFO L273 TraceCheckUtils]: 14: Hoare triple {416#false} assume !false; {416#false} is VALID [2018-11-23 12:09:48,481 INFO L134 CoverageAnalysis]: Checked inductivity of 3 backedges. 0 proven. 3 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:48,482 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:48,482 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 3 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 3 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:48,499 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:09:48,545 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:09:48,545 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:48,558 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:48,560 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:48,660 INFO L256 TraceCheckUtils]: 0: Hoare triple {415#true} call ULTIMATE.init(); {415#true} is VALID [2018-11-23 12:09:48,660 INFO L273 TraceCheckUtils]: 1: Hoare triple {415#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {415#true} is VALID [2018-11-23 12:09:48,661 INFO L273 TraceCheckUtils]: 2: Hoare triple {415#true} assume true; {415#true} is VALID [2018-11-23 12:09:48,661 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {415#true} {415#true} #48#return; {415#true} is VALID [2018-11-23 12:09:48,662 INFO L256 TraceCheckUtils]: 4: Hoare triple {415#true} call #t~ret6 := main(); {415#true} is VALID [2018-11-23 12:09:48,663 INFO L273 TraceCheckUtils]: 5: Hoare triple {415#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {438#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:48,664 INFO L273 TraceCheckUtils]: 6: Hoare triple {438#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {418#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:48,665 INFO L273 TraceCheckUtils]: 7: Hoare triple {418#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {419#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:48,669 INFO L273 TraceCheckUtils]: 8: Hoare triple {419#(<= main_~i~0 2)} assume !(~i~0 < 100000); {416#false} is VALID [2018-11-23 12:09:48,670 INFO L273 TraceCheckUtils]: 9: Hoare triple {416#false} havoc ~x~0;~x~0 := 0; {416#false} is VALID [2018-11-23 12:09:48,670 INFO L273 TraceCheckUtils]: 10: Hoare triple {416#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {416#false} is VALID [2018-11-23 12:09:48,670 INFO L256 TraceCheckUtils]: 11: Hoare triple {416#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {416#false} is VALID [2018-11-23 12:09:48,671 INFO L273 TraceCheckUtils]: 12: Hoare triple {416#false} ~cond := #in~cond; {416#false} is VALID [2018-11-23 12:09:48,671 INFO L273 TraceCheckUtils]: 13: Hoare triple {416#false} assume 0 == ~cond; {416#false} is VALID [2018-11-23 12:09:48,671 INFO L273 TraceCheckUtils]: 14: Hoare triple {416#false} assume !false; {416#false} is VALID [2018-11-23 12:09:48,672 INFO L134 CoverageAnalysis]: Checked inductivity of 3 backedges. 0 proven. 3 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:48,691 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:48,691 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [5, 5] total 6 [2018-11-23 12:09:48,691 INFO L78 Accepts]: Start accepts. Automaton has 6 states. Word has length 15 [2018-11-23 12:09:48,692 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:48,692 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 6 states. [2018-11-23 12:09:48,722 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 17 edges. 17 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:48,722 INFO L459 AbstractCegarLoop]: Interpolant automaton has 6 states [2018-11-23 12:09:48,722 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 6 interpolants. [2018-11-23 12:09:48,723 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=15, Invalid=15, Unknown=0, NotChecked=0, Total=30 [2018-11-23 12:09:48,723 INFO L87 Difference]: Start difference. First operand 20 states and 21 transitions. Second operand 6 states. [2018-11-23 12:09:48,898 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:48,898 INFO L93 Difference]: Finished difference Result 32 states and 34 transitions. [2018-11-23 12:09:48,898 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 5 states. [2018-11-23 12:09:48,899 INFO L78 Accepts]: Start accepts. Automaton has 6 states. Word has length 15 [2018-11-23 12:09:48,899 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:48,899 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 6 states. [2018-11-23 12:09:48,902 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 34 transitions. [2018-11-23 12:09:48,902 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 6 states. [2018-11-23 12:09:48,904 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 5 states to 5 states and 34 transitions. [2018-11-23 12:09:48,904 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 5 states and 34 transitions. [2018-11-23 12:09:48,996 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:48,997 INFO L225 Difference]: With dead ends: 32 [2018-11-23 12:09:48,999 INFO L226 Difference]: Without dead ends: 21 [2018-11-23 12:09:49,000 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 19 GetRequests, 15 SyntacticMatches, 0 SemanticMatches, 4 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 2 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=15, Invalid=15, Unknown=0, NotChecked=0, Total=30 [2018-11-23 12:09:49,000 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 21 states. [2018-11-23 12:09:49,017 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 21 to 21. [2018-11-23 12:09:49,017 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:49,017 INFO L82 GeneralOperation]: Start isEquivalent. First operand 21 states. Second operand 21 states. [2018-11-23 12:09:49,017 INFO L74 IsIncluded]: Start isIncluded. First operand 21 states. Second operand 21 states. [2018-11-23 12:09:49,017 INFO L87 Difference]: Start difference. First operand 21 states. Second operand 21 states. [2018-11-23 12:09:49,019 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:49,019 INFO L93 Difference]: Finished difference Result 21 states and 22 transitions. [2018-11-23 12:09:49,019 INFO L276 IsEmpty]: Start isEmpty. Operand 21 states and 22 transitions. [2018-11-23 12:09:49,020 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:49,020 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:49,020 INFO L74 IsIncluded]: Start isIncluded. First operand 21 states. Second operand 21 states. [2018-11-23 12:09:49,020 INFO L87 Difference]: Start difference. First operand 21 states. Second operand 21 states. [2018-11-23 12:09:49,022 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:49,022 INFO L93 Difference]: Finished difference Result 21 states and 22 transitions. [2018-11-23 12:09:49,022 INFO L276 IsEmpty]: Start isEmpty. Operand 21 states and 22 transitions. [2018-11-23 12:09:49,023 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:49,023 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:49,023 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:49,023 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:49,024 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 21 states. [2018-11-23 12:09:49,025 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 21 states to 21 states and 22 transitions. [2018-11-23 12:09:49,025 INFO L78 Accepts]: Start accepts. Automaton has 21 states and 22 transitions. Word has length 15 [2018-11-23 12:09:49,025 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:49,026 INFO L480 AbstractCegarLoop]: Abstraction has 21 states and 22 transitions. [2018-11-23 12:09:49,026 INFO L481 AbstractCegarLoop]: Interpolant automaton has 6 states. [2018-11-23 12:09:49,026 INFO L276 IsEmpty]: Start isEmpty. Operand 21 states and 22 transitions. [2018-11-23 12:09:49,026 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 17 [2018-11-23 12:09:49,027 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:49,027 INFO L402 BasicCegarLoop]: trace histogram [3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:49,027 INFO L423 AbstractCegarLoop]: === Iteration 5 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:49,027 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:49,028 INFO L82 PathProgramCache]: Analyzing trace with hash 2004063982, now seen corresponding path program 3 times [2018-11-23 12:09:49,028 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:49,028 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:49,029 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:49,029 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:49,029 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:49,046 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:49,186 INFO L256 TraceCheckUtils]: 0: Hoare triple {585#true} call ULTIMATE.init(); {585#true} is VALID [2018-11-23 12:09:49,187 INFO L273 TraceCheckUtils]: 1: Hoare triple {585#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {585#true} is VALID [2018-11-23 12:09:49,187 INFO L273 TraceCheckUtils]: 2: Hoare triple {585#true} assume true; {585#true} is VALID [2018-11-23 12:09:49,188 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {585#true} {585#true} #48#return; {585#true} is VALID [2018-11-23 12:09:49,188 INFO L256 TraceCheckUtils]: 4: Hoare triple {585#true} call #t~ret6 := main(); {585#true} is VALID [2018-11-23 12:09:49,189 INFO L273 TraceCheckUtils]: 5: Hoare triple {585#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {587#(= main_~i~0 0)} is VALID [2018-11-23 12:09:49,190 INFO L273 TraceCheckUtils]: 6: Hoare triple {587#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {588#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:49,191 INFO L273 TraceCheckUtils]: 7: Hoare triple {588#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {589#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:49,192 INFO L273 TraceCheckUtils]: 8: Hoare triple {589#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {590#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:49,202 INFO L273 TraceCheckUtils]: 9: Hoare triple {590#(<= main_~i~0 3)} assume !(~i~0 < 100000); {586#false} is VALID [2018-11-23 12:09:49,202 INFO L273 TraceCheckUtils]: 10: Hoare triple {586#false} havoc ~x~0;~x~0 := 0; {586#false} is VALID [2018-11-23 12:09:49,202 INFO L273 TraceCheckUtils]: 11: Hoare triple {586#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {586#false} is VALID [2018-11-23 12:09:49,203 INFO L256 TraceCheckUtils]: 12: Hoare triple {586#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {586#false} is VALID [2018-11-23 12:09:49,203 INFO L273 TraceCheckUtils]: 13: Hoare triple {586#false} ~cond := #in~cond; {586#false} is VALID [2018-11-23 12:09:49,203 INFO L273 TraceCheckUtils]: 14: Hoare triple {586#false} assume 0 == ~cond; {586#false} is VALID [2018-11-23 12:09:49,204 INFO L273 TraceCheckUtils]: 15: Hoare triple {586#false} assume !false; {586#false} is VALID [2018-11-23 12:09:49,204 INFO L134 CoverageAnalysis]: Checked inductivity of 6 backedges. 0 proven. 6 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:49,205 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:49,205 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 4 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 4 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:49,220 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:09:49,240 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 3 check-sat command(s) [2018-11-23 12:09:49,240 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:49,256 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:49,257 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:49,334 INFO L256 TraceCheckUtils]: 0: Hoare triple {585#true} call ULTIMATE.init(); {585#true} is VALID [2018-11-23 12:09:49,334 INFO L273 TraceCheckUtils]: 1: Hoare triple {585#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {585#true} is VALID [2018-11-23 12:09:49,335 INFO L273 TraceCheckUtils]: 2: Hoare triple {585#true} assume true; {585#true} is VALID [2018-11-23 12:09:49,335 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {585#true} {585#true} #48#return; {585#true} is VALID [2018-11-23 12:09:49,335 INFO L256 TraceCheckUtils]: 4: Hoare triple {585#true} call #t~ret6 := main(); {585#true} is VALID [2018-11-23 12:09:49,340 INFO L273 TraceCheckUtils]: 5: Hoare triple {585#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {609#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:49,342 INFO L273 TraceCheckUtils]: 6: Hoare triple {609#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {588#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:49,343 INFO L273 TraceCheckUtils]: 7: Hoare triple {588#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {589#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:49,343 INFO L273 TraceCheckUtils]: 8: Hoare triple {589#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {590#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:49,344 INFO L273 TraceCheckUtils]: 9: Hoare triple {590#(<= main_~i~0 3)} assume !(~i~0 < 100000); {586#false} is VALID [2018-11-23 12:09:49,344 INFO L273 TraceCheckUtils]: 10: Hoare triple {586#false} havoc ~x~0;~x~0 := 0; {586#false} is VALID [2018-11-23 12:09:49,345 INFO L273 TraceCheckUtils]: 11: Hoare triple {586#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {586#false} is VALID [2018-11-23 12:09:49,345 INFO L256 TraceCheckUtils]: 12: Hoare triple {586#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {586#false} is VALID [2018-11-23 12:09:49,346 INFO L273 TraceCheckUtils]: 13: Hoare triple {586#false} ~cond := #in~cond; {586#false} is VALID [2018-11-23 12:09:49,346 INFO L273 TraceCheckUtils]: 14: Hoare triple {586#false} assume 0 == ~cond; {586#false} is VALID [2018-11-23 12:09:49,347 INFO L273 TraceCheckUtils]: 15: Hoare triple {586#false} assume !false; {586#false} is VALID [2018-11-23 12:09:49,347 INFO L134 CoverageAnalysis]: Checked inductivity of 6 backedges. 0 proven. 6 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:49,366 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:49,366 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [6, 6] total 7 [2018-11-23 12:09:49,367 INFO L78 Accepts]: Start accepts. Automaton has 7 states. Word has length 16 [2018-11-23 12:09:49,368 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:49,368 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 7 states. [2018-11-23 12:09:49,443 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 18 edges. 18 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:49,444 INFO L459 AbstractCegarLoop]: Interpolant automaton has 7 states [2018-11-23 12:09:49,444 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 7 interpolants. [2018-11-23 12:09:49,444 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=21, Invalid=21, Unknown=0, NotChecked=0, Total=42 [2018-11-23 12:09:49,444 INFO L87 Difference]: Start difference. First operand 21 states and 22 transitions. Second operand 7 states. [2018-11-23 12:09:49,569 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:49,570 INFO L93 Difference]: Finished difference Result 33 states and 35 transitions. [2018-11-23 12:09:49,570 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 6 states. [2018-11-23 12:09:49,570 INFO L78 Accepts]: Start accepts. Automaton has 7 states. Word has length 16 [2018-11-23 12:09:49,571 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:49,571 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 7 states. [2018-11-23 12:09:49,573 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 6 states to 6 states and 35 transitions. [2018-11-23 12:09:49,573 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 7 states. [2018-11-23 12:09:49,575 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 6 states to 6 states and 35 transitions. [2018-11-23 12:09:49,576 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 6 states and 35 transitions. [2018-11-23 12:09:49,628 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 35 edges. 35 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:49,629 INFO L225 Difference]: With dead ends: 33 [2018-11-23 12:09:49,629 INFO L226 Difference]: Without dead ends: 22 [2018-11-23 12:09:49,630 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 21 GetRequests, 16 SyntacticMatches, 0 SemanticMatches, 5 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 4 ImplicationChecksByTransitivity, 0.1s TimeCoverageRelationStatistics Valid=21, Invalid=21, Unknown=0, NotChecked=0, Total=42 [2018-11-23 12:09:49,630 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 22 states. [2018-11-23 12:09:49,655 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 22 to 22. [2018-11-23 12:09:49,655 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:49,655 INFO L82 GeneralOperation]: Start isEquivalent. First operand 22 states. Second operand 22 states. [2018-11-23 12:09:49,655 INFO L74 IsIncluded]: Start isIncluded. First operand 22 states. Second operand 22 states. [2018-11-23 12:09:49,655 INFO L87 Difference]: Start difference. First operand 22 states. Second operand 22 states. [2018-11-23 12:09:49,657 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:49,657 INFO L93 Difference]: Finished difference Result 22 states and 23 transitions. [2018-11-23 12:09:49,657 INFO L276 IsEmpty]: Start isEmpty. Operand 22 states and 23 transitions. [2018-11-23 12:09:49,658 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:49,658 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:49,658 INFO L74 IsIncluded]: Start isIncluded. First operand 22 states. Second operand 22 states. [2018-11-23 12:09:49,658 INFO L87 Difference]: Start difference. First operand 22 states. Second operand 22 states. [2018-11-23 12:09:49,660 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:49,660 INFO L93 Difference]: Finished difference Result 22 states and 23 transitions. [2018-11-23 12:09:49,660 INFO L276 IsEmpty]: Start isEmpty. Operand 22 states and 23 transitions. [2018-11-23 12:09:49,661 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:49,661 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:49,661 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:49,661 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:49,661 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 22 states. [2018-11-23 12:09:49,663 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 22 states to 22 states and 23 transitions. [2018-11-23 12:09:49,663 INFO L78 Accepts]: Start accepts. Automaton has 22 states and 23 transitions. Word has length 16 [2018-11-23 12:09:49,663 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:49,663 INFO L480 AbstractCegarLoop]: Abstraction has 22 states and 23 transitions. [2018-11-23 12:09:49,663 INFO L481 AbstractCegarLoop]: Interpolant automaton has 7 states. [2018-11-23 12:09:49,664 INFO L276 IsEmpty]: Start isEmpty. Operand 22 states and 23 transitions. [2018-11-23 12:09:49,664 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 18 [2018-11-23 12:09:49,664 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:49,665 INFO L402 BasicCegarLoop]: trace histogram [4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:49,665 INFO L423 AbstractCegarLoop]: === Iteration 6 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:49,665 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:49,665 INFO L82 PathProgramCache]: Analyzing trace with hash -94637390, now seen corresponding path program 4 times [2018-11-23 12:09:49,665 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:49,666 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:49,666 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:49,667 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:49,667 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:49,690 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:49,815 INFO L256 TraceCheckUtils]: 0: Hoare triple {765#true} call ULTIMATE.init(); {765#true} is VALID [2018-11-23 12:09:49,815 INFO L273 TraceCheckUtils]: 1: Hoare triple {765#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {765#true} is VALID [2018-11-23 12:09:49,815 INFO L273 TraceCheckUtils]: 2: Hoare triple {765#true} assume true; {765#true} is VALID [2018-11-23 12:09:49,816 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {765#true} {765#true} #48#return; {765#true} is VALID [2018-11-23 12:09:49,816 INFO L256 TraceCheckUtils]: 4: Hoare triple {765#true} call #t~ret6 := main(); {765#true} is VALID [2018-11-23 12:09:49,831 INFO L273 TraceCheckUtils]: 5: Hoare triple {765#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {767#(= main_~i~0 0)} is VALID [2018-11-23 12:09:49,832 INFO L273 TraceCheckUtils]: 6: Hoare triple {767#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {768#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:49,834 INFO L273 TraceCheckUtils]: 7: Hoare triple {768#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {769#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:49,837 INFO L273 TraceCheckUtils]: 8: Hoare triple {769#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {770#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:49,838 INFO L273 TraceCheckUtils]: 9: Hoare triple {770#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {771#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:49,843 INFO L273 TraceCheckUtils]: 10: Hoare triple {771#(<= main_~i~0 4)} assume !(~i~0 < 100000); {766#false} is VALID [2018-11-23 12:09:49,843 INFO L273 TraceCheckUtils]: 11: Hoare triple {766#false} havoc ~x~0;~x~0 := 0; {766#false} is VALID [2018-11-23 12:09:49,843 INFO L273 TraceCheckUtils]: 12: Hoare triple {766#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {766#false} is VALID [2018-11-23 12:09:49,844 INFO L256 TraceCheckUtils]: 13: Hoare triple {766#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {766#false} is VALID [2018-11-23 12:09:49,844 INFO L273 TraceCheckUtils]: 14: Hoare triple {766#false} ~cond := #in~cond; {766#false} is VALID [2018-11-23 12:09:49,844 INFO L273 TraceCheckUtils]: 15: Hoare triple {766#false} assume 0 == ~cond; {766#false} is VALID [2018-11-23 12:09:49,845 INFO L273 TraceCheckUtils]: 16: Hoare triple {766#false} assume !false; {766#false} is VALID [2018-11-23 12:09:49,845 INFO L134 CoverageAnalysis]: Checked inductivity of 10 backedges. 0 proven. 10 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:49,846 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:49,846 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 5 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 5 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:49,857 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:09:49,875 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:09:49,876 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:49,904 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:49,905 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:50,058 INFO L256 TraceCheckUtils]: 0: Hoare triple {765#true} call ULTIMATE.init(); {765#true} is VALID [2018-11-23 12:09:50,059 INFO L273 TraceCheckUtils]: 1: Hoare triple {765#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {765#true} is VALID [2018-11-23 12:09:50,059 INFO L273 TraceCheckUtils]: 2: Hoare triple {765#true} assume true; {765#true} is VALID [2018-11-23 12:09:50,060 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {765#true} {765#true} #48#return; {765#true} is VALID [2018-11-23 12:09:50,060 INFO L256 TraceCheckUtils]: 4: Hoare triple {765#true} call #t~ret6 := main(); {765#true} is VALID [2018-11-23 12:09:50,061 INFO L273 TraceCheckUtils]: 5: Hoare triple {765#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {790#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:50,062 INFO L273 TraceCheckUtils]: 6: Hoare triple {790#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {768#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:50,063 INFO L273 TraceCheckUtils]: 7: Hoare triple {768#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {769#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:50,064 INFO L273 TraceCheckUtils]: 8: Hoare triple {769#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {770#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:50,066 INFO L273 TraceCheckUtils]: 9: Hoare triple {770#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {771#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:50,067 INFO L273 TraceCheckUtils]: 10: Hoare triple {771#(<= main_~i~0 4)} assume !(~i~0 < 100000); {766#false} is VALID [2018-11-23 12:09:50,067 INFO L273 TraceCheckUtils]: 11: Hoare triple {766#false} havoc ~x~0;~x~0 := 0; {766#false} is VALID [2018-11-23 12:09:50,068 INFO L273 TraceCheckUtils]: 12: Hoare triple {766#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {766#false} is VALID [2018-11-23 12:09:50,068 INFO L256 TraceCheckUtils]: 13: Hoare triple {766#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {766#false} is VALID [2018-11-23 12:09:50,068 INFO L273 TraceCheckUtils]: 14: Hoare triple {766#false} ~cond := #in~cond; {766#false} is VALID [2018-11-23 12:09:50,069 INFO L273 TraceCheckUtils]: 15: Hoare triple {766#false} assume 0 == ~cond; {766#false} is VALID [2018-11-23 12:09:50,069 INFO L273 TraceCheckUtils]: 16: Hoare triple {766#false} assume !false; {766#false} is VALID [2018-11-23 12:09:50,070 INFO L134 CoverageAnalysis]: Checked inductivity of 10 backedges. 0 proven. 10 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:50,089 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:50,090 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [7, 7] total 8 [2018-11-23 12:09:50,090 INFO L78 Accepts]: Start accepts. Automaton has 8 states. Word has length 17 [2018-11-23 12:09:50,090 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:50,090 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 8 states. [2018-11-23 12:09:50,110 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 19 edges. 19 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:50,111 INFO L459 AbstractCegarLoop]: Interpolant automaton has 8 states [2018-11-23 12:09:50,111 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 8 interpolants. [2018-11-23 12:09:50,111 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=28, Invalid=28, Unknown=0, NotChecked=0, Total=56 [2018-11-23 12:09:50,112 INFO L87 Difference]: Start difference. First operand 22 states and 23 transitions. Second operand 8 states. [2018-11-23 12:09:50,261 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:50,261 INFO L93 Difference]: Finished difference Result 34 states and 36 transitions. [2018-11-23 12:09:50,261 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 7 states. [2018-11-23 12:09:50,261 INFO L78 Accepts]: Start accepts. Automaton has 8 states. Word has length 17 [2018-11-23 12:09:50,262 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:50,262 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 8 states. [2018-11-23 12:09:50,264 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 7 states to 7 states and 36 transitions. [2018-11-23 12:09:50,264 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 8 states. [2018-11-23 12:09:50,266 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 7 states to 7 states and 36 transitions. [2018-11-23 12:09:50,266 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 7 states and 36 transitions. [2018-11-23 12:09:50,316 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:50,318 INFO L225 Difference]: With dead ends: 34 [2018-11-23 12:09:50,318 INFO L226 Difference]: Without dead ends: 23 [2018-11-23 12:09:50,319 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 23 GetRequests, 17 SyntacticMatches, 0 SemanticMatches, 6 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 6 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=28, Invalid=28, Unknown=0, NotChecked=0, Total=56 [2018-11-23 12:09:50,319 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 23 states. [2018-11-23 12:09:50,329 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 23 to 23. [2018-11-23 12:09:50,329 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:50,330 INFO L82 GeneralOperation]: Start isEquivalent. First operand 23 states. Second operand 23 states. [2018-11-23 12:09:50,330 INFO L74 IsIncluded]: Start isIncluded. First operand 23 states. Second operand 23 states. [2018-11-23 12:09:50,330 INFO L87 Difference]: Start difference. First operand 23 states. Second operand 23 states. [2018-11-23 12:09:50,332 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:50,332 INFO L93 Difference]: Finished difference Result 23 states and 24 transitions. [2018-11-23 12:09:50,332 INFO L276 IsEmpty]: Start isEmpty. Operand 23 states and 24 transitions. [2018-11-23 12:09:50,333 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:50,333 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:50,333 INFO L74 IsIncluded]: Start isIncluded. First operand 23 states. Second operand 23 states. [2018-11-23 12:09:50,333 INFO L87 Difference]: Start difference. First operand 23 states. Second operand 23 states. [2018-11-23 12:09:50,336 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:50,336 INFO L93 Difference]: Finished difference Result 23 states and 24 transitions. [2018-11-23 12:09:50,336 INFO L276 IsEmpty]: Start isEmpty. Operand 23 states and 24 transitions. [2018-11-23 12:09:50,337 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:50,337 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:50,337 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:50,337 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:50,338 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 23 states. [2018-11-23 12:09:50,339 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 23 states to 23 states and 24 transitions. [2018-11-23 12:09:50,339 INFO L78 Accepts]: Start accepts. Automaton has 23 states and 24 transitions. Word has length 17 [2018-11-23 12:09:50,339 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:50,340 INFO L480 AbstractCegarLoop]: Abstraction has 23 states and 24 transitions. [2018-11-23 12:09:50,340 INFO L481 AbstractCegarLoop]: Interpolant automaton has 8 states. [2018-11-23 12:09:50,340 INFO L276 IsEmpty]: Start isEmpty. Operand 23 states and 24 transitions. [2018-11-23 12:09:50,340 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 19 [2018-11-23 12:09:50,340 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:50,341 INFO L402 BasicCegarLoop]: trace histogram [5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:50,341 INFO L423 AbstractCegarLoop]: === Iteration 7 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:50,341 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:50,341 INFO L82 PathProgramCache]: Analyzing trace with hash -729870482, now seen corresponding path program 5 times [2018-11-23 12:09:50,342 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:50,342 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:50,343 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:50,343 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:50,343 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:50,359 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:50,547 INFO L256 TraceCheckUtils]: 0: Hoare triple {955#true} call ULTIMATE.init(); {955#true} is VALID [2018-11-23 12:09:50,548 INFO L273 TraceCheckUtils]: 1: Hoare triple {955#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {955#true} is VALID [2018-11-23 12:09:50,548 INFO L273 TraceCheckUtils]: 2: Hoare triple {955#true} assume true; {955#true} is VALID [2018-11-23 12:09:50,548 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {955#true} {955#true} #48#return; {955#true} is VALID [2018-11-23 12:09:50,549 INFO L256 TraceCheckUtils]: 4: Hoare triple {955#true} call #t~ret6 := main(); {955#true} is VALID [2018-11-23 12:09:50,550 INFO L273 TraceCheckUtils]: 5: Hoare triple {955#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {957#(= main_~i~0 0)} is VALID [2018-11-23 12:09:50,561 INFO L273 TraceCheckUtils]: 6: Hoare triple {957#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {958#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:50,562 INFO L273 TraceCheckUtils]: 7: Hoare triple {958#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {959#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:50,563 INFO L273 TraceCheckUtils]: 8: Hoare triple {959#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {960#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:50,564 INFO L273 TraceCheckUtils]: 9: Hoare triple {960#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {961#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:50,565 INFO L273 TraceCheckUtils]: 10: Hoare triple {961#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {962#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:50,566 INFO L273 TraceCheckUtils]: 11: Hoare triple {962#(<= main_~i~0 5)} assume !(~i~0 < 100000); {956#false} is VALID [2018-11-23 12:09:50,566 INFO L273 TraceCheckUtils]: 12: Hoare triple {956#false} havoc ~x~0;~x~0 := 0; {956#false} is VALID [2018-11-23 12:09:50,566 INFO L273 TraceCheckUtils]: 13: Hoare triple {956#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {956#false} is VALID [2018-11-23 12:09:50,567 INFO L256 TraceCheckUtils]: 14: Hoare triple {956#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {956#false} is VALID [2018-11-23 12:09:50,567 INFO L273 TraceCheckUtils]: 15: Hoare triple {956#false} ~cond := #in~cond; {956#false} is VALID [2018-11-23 12:09:50,568 INFO L273 TraceCheckUtils]: 16: Hoare triple {956#false} assume 0 == ~cond; {956#false} is VALID [2018-11-23 12:09:50,568 INFO L273 TraceCheckUtils]: 17: Hoare triple {956#false} assume !false; {956#false} is VALID [2018-11-23 12:09:50,569 INFO L134 CoverageAnalysis]: Checked inductivity of 15 backedges. 0 proven. 15 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:50,569 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:50,569 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 6 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 6 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:50,578 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:09:50,610 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 4 check-sat command(s) [2018-11-23 12:09:50,610 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:50,624 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:50,625 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:50,715 INFO L256 TraceCheckUtils]: 0: Hoare triple {955#true} call ULTIMATE.init(); {955#true} is VALID [2018-11-23 12:09:50,716 INFO L273 TraceCheckUtils]: 1: Hoare triple {955#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {955#true} is VALID [2018-11-23 12:09:50,716 INFO L273 TraceCheckUtils]: 2: Hoare triple {955#true} assume true; {955#true} is VALID [2018-11-23 12:09:50,717 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {955#true} {955#true} #48#return; {955#true} is VALID [2018-11-23 12:09:50,717 INFO L256 TraceCheckUtils]: 4: Hoare triple {955#true} call #t~ret6 := main(); {955#true} is VALID [2018-11-23 12:09:50,718 INFO L273 TraceCheckUtils]: 5: Hoare triple {955#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {981#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:50,719 INFO L273 TraceCheckUtils]: 6: Hoare triple {981#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {958#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:50,720 INFO L273 TraceCheckUtils]: 7: Hoare triple {958#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {959#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:50,727 INFO L273 TraceCheckUtils]: 8: Hoare triple {959#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {960#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:50,728 INFO L273 TraceCheckUtils]: 9: Hoare triple {960#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {961#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:50,732 INFO L273 TraceCheckUtils]: 10: Hoare triple {961#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {962#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:50,732 INFO L273 TraceCheckUtils]: 11: Hoare triple {962#(<= main_~i~0 5)} assume !(~i~0 < 100000); {956#false} is VALID [2018-11-23 12:09:50,732 INFO L273 TraceCheckUtils]: 12: Hoare triple {956#false} havoc ~x~0;~x~0 := 0; {956#false} is VALID [2018-11-23 12:09:50,733 INFO L273 TraceCheckUtils]: 13: Hoare triple {956#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {956#false} is VALID [2018-11-23 12:09:50,733 INFO L256 TraceCheckUtils]: 14: Hoare triple {956#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {956#false} is VALID [2018-11-23 12:09:50,733 INFO L273 TraceCheckUtils]: 15: Hoare triple {956#false} ~cond := #in~cond; {956#false} is VALID [2018-11-23 12:09:50,734 INFO L273 TraceCheckUtils]: 16: Hoare triple {956#false} assume 0 == ~cond; {956#false} is VALID [2018-11-23 12:09:50,734 INFO L273 TraceCheckUtils]: 17: Hoare triple {956#false} assume !false; {956#false} is VALID [2018-11-23 12:09:50,735 INFO L134 CoverageAnalysis]: Checked inductivity of 15 backedges. 0 proven. 15 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:50,754 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:50,754 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [8, 8] total 9 [2018-11-23 12:09:50,754 INFO L78 Accepts]: Start accepts. Automaton has 9 states. Word has length 18 [2018-11-23 12:09:50,754 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:50,755 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 9 states. [2018-11-23 12:09:50,809 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 20 edges. 20 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:50,809 INFO L459 AbstractCegarLoop]: Interpolant automaton has 9 states [2018-11-23 12:09:50,809 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 9 interpolants. [2018-11-23 12:09:50,809 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=36, Invalid=36, Unknown=0, NotChecked=0, Total=72 [2018-11-23 12:09:50,809 INFO L87 Difference]: Start difference. First operand 23 states and 24 transitions. Second operand 9 states. [2018-11-23 12:09:50,938 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:50,938 INFO L93 Difference]: Finished difference Result 35 states and 37 transitions. [2018-11-23 12:09:50,938 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 8 states. [2018-11-23 12:09:50,939 INFO L78 Accepts]: Start accepts. Automaton has 9 states. Word has length 18 [2018-11-23 12:09:50,939 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:50,940 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 9 states. [2018-11-23 12:09:50,942 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 8 states to 8 states and 37 transitions. [2018-11-23 12:09:50,942 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 9 states. [2018-11-23 12:09:50,944 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 8 states to 8 states and 37 transitions. [2018-11-23 12:09:50,944 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 8 states and 37 transitions. [2018-11-23 12:09:51,011 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 37 edges. 37 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:51,013 INFO L225 Difference]: With dead ends: 35 [2018-11-23 12:09:51,013 INFO L226 Difference]: Without dead ends: 24 [2018-11-23 12:09:51,014 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 25 GetRequests, 18 SyntacticMatches, 0 SemanticMatches, 7 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 8 ImplicationChecksByTransitivity, 0.1s TimeCoverageRelationStatistics Valid=36, Invalid=36, Unknown=0, NotChecked=0, Total=72 [2018-11-23 12:09:51,014 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 24 states. [2018-11-23 12:09:51,030 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 24 to 24. [2018-11-23 12:09:51,030 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:51,030 INFO L82 GeneralOperation]: Start isEquivalent. First operand 24 states. Second operand 24 states. [2018-11-23 12:09:51,031 INFO L74 IsIncluded]: Start isIncluded. First operand 24 states. Second operand 24 states. [2018-11-23 12:09:51,031 INFO L87 Difference]: Start difference. First operand 24 states. Second operand 24 states. [2018-11-23 12:09:51,033 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:51,033 INFO L93 Difference]: Finished difference Result 24 states and 25 transitions. [2018-11-23 12:09:51,033 INFO L276 IsEmpty]: Start isEmpty. Operand 24 states and 25 transitions. [2018-11-23 12:09:51,034 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:51,034 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:51,034 INFO L74 IsIncluded]: Start isIncluded. First operand 24 states. Second operand 24 states. [2018-11-23 12:09:51,034 INFO L87 Difference]: Start difference. First operand 24 states. Second operand 24 states. [2018-11-23 12:09:51,036 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:51,036 INFO L93 Difference]: Finished difference Result 24 states and 25 transitions. [2018-11-23 12:09:51,036 INFO L276 IsEmpty]: Start isEmpty. Operand 24 states and 25 transitions. [2018-11-23 12:09:51,036 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:51,037 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:51,037 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:51,037 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:51,037 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 24 states. [2018-11-23 12:09:51,038 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 24 states to 24 states and 25 transitions. [2018-11-23 12:09:51,039 INFO L78 Accepts]: Start accepts. Automaton has 24 states and 25 transitions. Word has length 18 [2018-11-23 12:09:51,039 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:51,039 INFO L480 AbstractCegarLoop]: Abstraction has 24 states and 25 transitions. [2018-11-23 12:09:51,039 INFO L481 AbstractCegarLoop]: Interpolant automaton has 9 states. [2018-11-23 12:09:51,039 INFO L276 IsEmpty]: Start isEmpty. Operand 24 states and 25 transitions. [2018-11-23 12:09:51,040 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 20 [2018-11-23 12:09:51,040 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:51,040 INFO L402 BasicCegarLoop]: trace histogram [6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:51,041 INFO L423 AbstractCegarLoop]: === Iteration 8 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:51,041 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:51,041 INFO L82 PathProgramCache]: Analyzing trace with hash 1052740146, now seen corresponding path program 6 times [2018-11-23 12:09:51,041 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:51,041 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:51,042 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:51,042 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:51,043 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:51,060 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:51,221 INFO L256 TraceCheckUtils]: 0: Hoare triple {1155#true} call ULTIMATE.init(); {1155#true} is VALID [2018-11-23 12:09:51,221 INFO L273 TraceCheckUtils]: 1: Hoare triple {1155#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1155#true} is VALID [2018-11-23 12:09:51,222 INFO L273 TraceCheckUtils]: 2: Hoare triple {1155#true} assume true; {1155#true} is VALID [2018-11-23 12:09:51,222 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1155#true} {1155#true} #48#return; {1155#true} is VALID [2018-11-23 12:09:51,222 INFO L256 TraceCheckUtils]: 4: Hoare triple {1155#true} call #t~ret6 := main(); {1155#true} is VALID [2018-11-23 12:09:51,223 INFO L273 TraceCheckUtils]: 5: Hoare triple {1155#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {1157#(= main_~i~0 0)} is VALID [2018-11-23 12:09:51,225 INFO L273 TraceCheckUtils]: 6: Hoare triple {1157#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1158#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:51,226 INFO L273 TraceCheckUtils]: 7: Hoare triple {1158#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1159#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:51,227 INFO L273 TraceCheckUtils]: 8: Hoare triple {1159#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1160#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:51,228 INFO L273 TraceCheckUtils]: 9: Hoare triple {1160#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1161#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:51,230 INFO L273 TraceCheckUtils]: 10: Hoare triple {1161#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1162#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:51,231 INFO L273 TraceCheckUtils]: 11: Hoare triple {1162#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1163#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:51,232 INFO L273 TraceCheckUtils]: 12: Hoare triple {1163#(<= main_~i~0 6)} assume !(~i~0 < 100000); {1156#false} is VALID [2018-11-23 12:09:51,232 INFO L273 TraceCheckUtils]: 13: Hoare triple {1156#false} havoc ~x~0;~x~0 := 0; {1156#false} is VALID [2018-11-23 12:09:51,233 INFO L273 TraceCheckUtils]: 14: Hoare triple {1156#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {1156#false} is VALID [2018-11-23 12:09:51,233 INFO L256 TraceCheckUtils]: 15: Hoare triple {1156#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {1156#false} is VALID [2018-11-23 12:09:51,233 INFO L273 TraceCheckUtils]: 16: Hoare triple {1156#false} ~cond := #in~cond; {1156#false} is VALID [2018-11-23 12:09:51,234 INFO L273 TraceCheckUtils]: 17: Hoare triple {1156#false} assume 0 == ~cond; {1156#false} is VALID [2018-11-23 12:09:51,234 INFO L273 TraceCheckUtils]: 18: Hoare triple {1156#false} assume !false; {1156#false} is VALID [2018-11-23 12:09:51,236 INFO L134 CoverageAnalysis]: Checked inductivity of 21 backedges. 0 proven. 21 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:51,236 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:51,236 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 7 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 7 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:51,249 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE [2018-11-23 12:09:51,318 INFO L249 tOrderPrioritization]: Assert order MIX_INSIDE_OUTSIDE issued 4 check-sat command(s) [2018-11-23 12:09:51,318 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:51,330 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:51,331 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:51,419 INFO L256 TraceCheckUtils]: 0: Hoare triple {1155#true} call ULTIMATE.init(); {1155#true} is VALID [2018-11-23 12:09:51,420 INFO L273 TraceCheckUtils]: 1: Hoare triple {1155#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1155#true} is VALID [2018-11-23 12:09:51,421 INFO L273 TraceCheckUtils]: 2: Hoare triple {1155#true} assume true; {1155#true} is VALID [2018-11-23 12:09:51,421 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1155#true} {1155#true} #48#return; {1155#true} is VALID [2018-11-23 12:09:51,421 INFO L256 TraceCheckUtils]: 4: Hoare triple {1155#true} call #t~ret6 := main(); {1155#true} is VALID [2018-11-23 12:09:51,422 INFO L273 TraceCheckUtils]: 5: Hoare triple {1155#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {1182#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:51,423 INFO L273 TraceCheckUtils]: 6: Hoare triple {1182#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1158#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:51,424 INFO L273 TraceCheckUtils]: 7: Hoare triple {1158#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1159#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:51,425 INFO L273 TraceCheckUtils]: 8: Hoare triple {1159#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1160#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:51,427 INFO L273 TraceCheckUtils]: 9: Hoare triple {1160#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1161#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:51,428 INFO L273 TraceCheckUtils]: 10: Hoare triple {1161#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1162#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:51,445 INFO L273 TraceCheckUtils]: 11: Hoare triple {1162#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1163#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:51,446 INFO L273 TraceCheckUtils]: 12: Hoare triple {1163#(<= main_~i~0 6)} assume !(~i~0 < 100000); {1156#false} is VALID [2018-11-23 12:09:51,446 INFO L273 TraceCheckUtils]: 13: Hoare triple {1156#false} havoc ~x~0;~x~0 := 0; {1156#false} is VALID [2018-11-23 12:09:51,446 INFO L273 TraceCheckUtils]: 14: Hoare triple {1156#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {1156#false} is VALID [2018-11-23 12:09:51,446 INFO L256 TraceCheckUtils]: 15: Hoare triple {1156#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {1156#false} is VALID [2018-11-23 12:09:51,447 INFO L273 TraceCheckUtils]: 16: Hoare triple {1156#false} ~cond := #in~cond; {1156#false} is VALID [2018-11-23 12:09:51,447 INFO L273 TraceCheckUtils]: 17: Hoare triple {1156#false} assume 0 == ~cond; {1156#false} is VALID [2018-11-23 12:09:51,447 INFO L273 TraceCheckUtils]: 18: Hoare triple {1156#false} assume !false; {1156#false} is VALID [2018-11-23 12:09:51,448 INFO L134 CoverageAnalysis]: Checked inductivity of 21 backedges. 0 proven. 21 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:51,467 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:51,467 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [9, 9] total 10 [2018-11-23 12:09:51,467 INFO L78 Accepts]: Start accepts. Automaton has 10 states. Word has length 19 [2018-11-23 12:09:51,468 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:51,468 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 10 states. [2018-11-23 12:09:51,490 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 21 edges. 21 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:51,490 INFO L459 AbstractCegarLoop]: Interpolant automaton has 10 states [2018-11-23 12:09:51,491 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 10 interpolants. [2018-11-23 12:09:51,491 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=45, Invalid=45, Unknown=0, NotChecked=0, Total=90 [2018-11-23 12:09:51,491 INFO L87 Difference]: Start difference. First operand 24 states and 25 transitions. Second operand 10 states. [2018-11-23 12:09:51,660 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:51,660 INFO L93 Difference]: Finished difference Result 36 states and 38 transitions. [2018-11-23 12:09:51,660 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 9 states. [2018-11-23 12:09:51,660 INFO L78 Accepts]: Start accepts. Automaton has 10 states. Word has length 19 [2018-11-23 12:09:51,661 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:51,661 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 10 states. [2018-11-23 12:09:51,663 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 9 states to 9 states and 38 transitions. [2018-11-23 12:09:51,663 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 10 states. [2018-11-23 12:09:51,665 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 9 states to 9 states and 38 transitions. [2018-11-23 12:09:51,665 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 9 states and 38 transitions. [2018-11-23 12:09:51,713 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:51,714 INFO L225 Difference]: With dead ends: 36 [2018-11-23 12:09:51,714 INFO L226 Difference]: Without dead ends: 25 [2018-11-23 12:09:51,715 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 27 GetRequests, 19 SyntacticMatches, 0 SemanticMatches, 8 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 10 ImplicationChecksByTransitivity, 0.1s TimeCoverageRelationStatistics Valid=45, Invalid=45, Unknown=0, NotChecked=0, Total=90 [2018-11-23 12:09:51,715 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 25 states. [2018-11-23 12:09:51,730 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 25 to 25. [2018-11-23 12:09:51,731 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:51,731 INFO L82 GeneralOperation]: Start isEquivalent. First operand 25 states. Second operand 25 states. [2018-11-23 12:09:51,731 INFO L74 IsIncluded]: Start isIncluded. First operand 25 states. Second operand 25 states. [2018-11-23 12:09:51,731 INFO L87 Difference]: Start difference. First operand 25 states. Second operand 25 states. [2018-11-23 12:09:51,732 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:51,732 INFO L93 Difference]: Finished difference Result 25 states and 26 transitions. [2018-11-23 12:09:51,732 INFO L276 IsEmpty]: Start isEmpty. Operand 25 states and 26 transitions. [2018-11-23 12:09:51,733 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:51,733 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:51,733 INFO L74 IsIncluded]: Start isIncluded. First operand 25 states. Second operand 25 states. [2018-11-23 12:09:51,733 INFO L87 Difference]: Start difference. First operand 25 states. Second operand 25 states. [2018-11-23 12:09:51,734 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:51,735 INFO L93 Difference]: Finished difference Result 25 states and 26 transitions. [2018-11-23 12:09:51,735 INFO L276 IsEmpty]: Start isEmpty. Operand 25 states and 26 transitions. [2018-11-23 12:09:51,735 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:51,735 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:51,735 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:51,735 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:51,736 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 25 states. [2018-11-23 12:09:51,737 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 25 states to 25 states and 26 transitions. [2018-11-23 12:09:51,737 INFO L78 Accepts]: Start accepts. Automaton has 25 states and 26 transitions. Word has length 19 [2018-11-23 12:09:51,737 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:51,737 INFO L480 AbstractCegarLoop]: Abstraction has 25 states and 26 transitions. [2018-11-23 12:09:51,737 INFO L481 AbstractCegarLoop]: Interpolant automaton has 10 states. [2018-11-23 12:09:51,737 INFO L276 IsEmpty]: Start isEmpty. Operand 25 states and 26 transitions. [2018-11-23 12:09:51,738 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 21 [2018-11-23 12:09:51,738 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:51,738 INFO L402 BasicCegarLoop]: trace histogram [7, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:51,738 INFO L423 AbstractCegarLoop]: === Iteration 9 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:51,738 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:51,739 INFO L82 PathProgramCache]: Analyzing trace with hash 479094766, now seen corresponding path program 7 times [2018-11-23 12:09:51,739 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:51,739 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:51,740 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:51,740 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:51,740 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:51,756 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:51,931 INFO L256 TraceCheckUtils]: 0: Hoare triple {1365#true} call ULTIMATE.init(); {1365#true} is VALID [2018-11-23 12:09:51,931 INFO L273 TraceCheckUtils]: 1: Hoare triple {1365#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1365#true} is VALID [2018-11-23 12:09:51,932 INFO L273 TraceCheckUtils]: 2: Hoare triple {1365#true} assume true; {1365#true} is VALID [2018-11-23 12:09:51,932 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1365#true} {1365#true} #48#return; {1365#true} is VALID [2018-11-23 12:09:51,932 INFO L256 TraceCheckUtils]: 4: Hoare triple {1365#true} call #t~ret6 := main(); {1365#true} is VALID [2018-11-23 12:09:51,933 INFO L273 TraceCheckUtils]: 5: Hoare triple {1365#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {1367#(= main_~i~0 0)} is VALID [2018-11-23 12:09:51,934 INFO L273 TraceCheckUtils]: 6: Hoare triple {1367#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1368#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:51,935 INFO L273 TraceCheckUtils]: 7: Hoare triple {1368#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1369#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:51,936 INFO L273 TraceCheckUtils]: 8: Hoare triple {1369#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1370#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:51,937 INFO L273 TraceCheckUtils]: 9: Hoare triple {1370#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1371#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:51,939 INFO L273 TraceCheckUtils]: 10: Hoare triple {1371#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1372#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:51,940 INFO L273 TraceCheckUtils]: 11: Hoare triple {1372#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1373#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:51,941 INFO L273 TraceCheckUtils]: 12: Hoare triple {1373#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1374#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:51,942 INFO L273 TraceCheckUtils]: 13: Hoare triple {1374#(<= main_~i~0 7)} assume !(~i~0 < 100000); {1366#false} is VALID [2018-11-23 12:09:51,943 INFO L273 TraceCheckUtils]: 14: Hoare triple {1366#false} havoc ~x~0;~x~0 := 0; {1366#false} is VALID [2018-11-23 12:09:51,943 INFO L273 TraceCheckUtils]: 15: Hoare triple {1366#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {1366#false} is VALID [2018-11-23 12:09:51,943 INFO L256 TraceCheckUtils]: 16: Hoare triple {1366#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {1366#false} is VALID [2018-11-23 12:09:51,944 INFO L273 TraceCheckUtils]: 17: Hoare triple {1366#false} ~cond := #in~cond; {1366#false} is VALID [2018-11-23 12:09:51,944 INFO L273 TraceCheckUtils]: 18: Hoare triple {1366#false} assume 0 == ~cond; {1366#false} is VALID [2018-11-23 12:09:51,944 INFO L273 TraceCheckUtils]: 19: Hoare triple {1366#false} assume !false; {1366#false} is VALID [2018-11-23 12:09:51,945 INFO L134 CoverageAnalysis]: Checked inductivity of 28 backedges. 0 proven. 28 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:51,945 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:51,945 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 8 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 8 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:51,962 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:51,994 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:52,019 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:52,020 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:52,306 INFO L256 TraceCheckUtils]: 0: Hoare triple {1365#true} call ULTIMATE.init(); {1365#true} is VALID [2018-11-23 12:09:52,306 INFO L273 TraceCheckUtils]: 1: Hoare triple {1365#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1365#true} is VALID [2018-11-23 12:09:52,306 INFO L273 TraceCheckUtils]: 2: Hoare triple {1365#true} assume true; {1365#true} is VALID [2018-11-23 12:09:52,307 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1365#true} {1365#true} #48#return; {1365#true} is VALID [2018-11-23 12:09:52,307 INFO L256 TraceCheckUtils]: 4: Hoare triple {1365#true} call #t~ret6 := main(); {1365#true} is VALID [2018-11-23 12:09:52,316 INFO L273 TraceCheckUtils]: 5: Hoare triple {1365#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {1393#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:52,325 INFO L273 TraceCheckUtils]: 6: Hoare triple {1393#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1368#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:52,326 INFO L273 TraceCheckUtils]: 7: Hoare triple {1368#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1369#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:52,327 INFO L273 TraceCheckUtils]: 8: Hoare triple {1369#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1370#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:52,328 INFO L273 TraceCheckUtils]: 9: Hoare triple {1370#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1371#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:52,333 INFO L273 TraceCheckUtils]: 10: Hoare triple {1371#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1372#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:52,336 INFO L273 TraceCheckUtils]: 11: Hoare triple {1372#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1373#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:52,339 INFO L273 TraceCheckUtils]: 12: Hoare triple {1373#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1374#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:52,340 INFO L273 TraceCheckUtils]: 13: Hoare triple {1374#(<= main_~i~0 7)} assume !(~i~0 < 100000); {1366#false} is VALID [2018-11-23 12:09:52,340 INFO L273 TraceCheckUtils]: 14: Hoare triple {1366#false} havoc ~x~0;~x~0 := 0; {1366#false} is VALID [2018-11-23 12:09:52,340 INFO L273 TraceCheckUtils]: 15: Hoare triple {1366#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {1366#false} is VALID [2018-11-23 12:09:52,340 INFO L256 TraceCheckUtils]: 16: Hoare triple {1366#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {1366#false} is VALID [2018-11-23 12:09:52,341 INFO L273 TraceCheckUtils]: 17: Hoare triple {1366#false} ~cond := #in~cond; {1366#false} is VALID [2018-11-23 12:09:52,341 INFO L273 TraceCheckUtils]: 18: Hoare triple {1366#false} assume 0 == ~cond; {1366#false} is VALID [2018-11-23 12:09:52,341 INFO L273 TraceCheckUtils]: 19: Hoare triple {1366#false} assume !false; {1366#false} is VALID [2018-11-23 12:09:52,342 INFO L134 CoverageAnalysis]: Checked inductivity of 28 backedges. 0 proven. 28 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:52,361 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:52,361 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [10, 10] total 11 [2018-11-23 12:09:52,361 INFO L78 Accepts]: Start accepts. Automaton has 11 states. Word has length 20 [2018-11-23 12:09:52,362 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:52,362 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 11 states. [2018-11-23 12:09:52,390 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 22 edges. 22 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:52,390 INFO L459 AbstractCegarLoop]: Interpolant automaton has 11 states [2018-11-23 12:09:52,391 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 11 interpolants. [2018-11-23 12:09:52,391 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=55, Invalid=55, Unknown=0, NotChecked=0, Total=110 [2018-11-23 12:09:52,391 INFO L87 Difference]: Start difference. First operand 25 states and 26 transitions. Second operand 11 states. [2018-11-23 12:09:52,593 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:52,593 INFO L93 Difference]: Finished difference Result 37 states and 39 transitions. [2018-11-23 12:09:52,593 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 10 states. [2018-11-23 12:09:52,594 INFO L78 Accepts]: Start accepts. Automaton has 11 states. Word has length 20 [2018-11-23 12:09:52,594 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:52,594 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 11 states. [2018-11-23 12:09:52,595 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 10 states to 10 states and 39 transitions. [2018-11-23 12:09:52,596 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 11 states. [2018-11-23 12:09:52,597 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 10 states to 10 states and 39 transitions. [2018-11-23 12:09:52,597 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 10 states and 39 transitions. [2018-11-23 12:09:52,643 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:52,645 INFO L225 Difference]: With dead ends: 37 [2018-11-23 12:09:52,645 INFO L226 Difference]: Without dead ends: 26 [2018-11-23 12:09:52,646 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 29 GetRequests, 20 SyntacticMatches, 0 SemanticMatches, 9 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 12 ImplicationChecksByTransitivity, 0.0s TimeCoverageRelationStatistics Valid=55, Invalid=55, Unknown=0, NotChecked=0, Total=110 [2018-11-23 12:09:52,646 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 26 states. [2018-11-23 12:09:52,664 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 26 to 26. [2018-11-23 12:09:52,664 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:52,664 INFO L82 GeneralOperation]: Start isEquivalent. First operand 26 states. Second operand 26 states. [2018-11-23 12:09:52,664 INFO L74 IsIncluded]: Start isIncluded. First operand 26 states. Second operand 26 states. [2018-11-23 12:09:52,665 INFO L87 Difference]: Start difference. First operand 26 states. Second operand 26 states. [2018-11-23 12:09:52,667 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:52,667 INFO L93 Difference]: Finished difference Result 26 states and 27 transitions. [2018-11-23 12:09:52,667 INFO L276 IsEmpty]: Start isEmpty. Operand 26 states and 27 transitions. [2018-11-23 12:09:52,668 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:52,668 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:52,668 INFO L74 IsIncluded]: Start isIncluded. First operand 26 states. Second operand 26 states. [2018-11-23 12:09:52,668 INFO L87 Difference]: Start difference. First operand 26 states. Second operand 26 states. [2018-11-23 12:09:52,670 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:52,670 INFO L93 Difference]: Finished difference Result 26 states and 27 transitions. [2018-11-23 12:09:52,670 INFO L276 IsEmpty]: Start isEmpty. Operand 26 states and 27 transitions. [2018-11-23 12:09:52,671 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:52,671 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:52,671 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:52,671 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:52,671 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 26 states. [2018-11-23 12:09:52,672 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 26 states to 26 states and 27 transitions. [2018-11-23 12:09:52,673 INFO L78 Accepts]: Start accepts. Automaton has 26 states and 27 transitions. Word has length 20 [2018-11-23 12:09:52,673 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:52,673 INFO L480 AbstractCegarLoop]: Abstraction has 26 states and 27 transitions. [2018-11-23 12:09:52,673 INFO L481 AbstractCegarLoop]: Interpolant automaton has 11 states. [2018-11-23 12:09:52,673 INFO L276 IsEmpty]: Start isEmpty. Operand 26 states and 27 transitions. [2018-11-23 12:09:52,674 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 22 [2018-11-23 12:09:52,674 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:52,674 INFO L402 BasicCegarLoop]: trace histogram [8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:52,674 INFO L423 AbstractCegarLoop]: === Iteration 10 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:52,674 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:52,675 INFO L82 PathProgramCache]: Analyzing trace with hash -124042830, now seen corresponding path program 8 times [2018-11-23 12:09:52,675 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:52,675 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:52,676 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:52,676 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:52,676 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:52,702 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:52,998 INFO L256 TraceCheckUtils]: 0: Hoare triple {1585#true} call ULTIMATE.init(); {1585#true} is VALID [2018-11-23 12:09:52,998 INFO L273 TraceCheckUtils]: 1: Hoare triple {1585#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1585#true} is VALID [2018-11-23 12:09:52,998 INFO L273 TraceCheckUtils]: 2: Hoare triple {1585#true} assume true; {1585#true} is VALID [2018-11-23 12:09:52,999 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1585#true} {1585#true} #48#return; {1585#true} is VALID [2018-11-23 12:09:52,999 INFO L256 TraceCheckUtils]: 4: Hoare triple {1585#true} call #t~ret6 := main(); {1585#true} is VALID [2018-11-23 12:09:52,999 INFO L273 TraceCheckUtils]: 5: Hoare triple {1585#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {1587#(= main_~i~0 0)} is VALID [2018-11-23 12:09:53,000 INFO L273 TraceCheckUtils]: 6: Hoare triple {1587#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1588#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:53,008 INFO L273 TraceCheckUtils]: 7: Hoare triple {1588#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1589#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:53,008 INFO L273 TraceCheckUtils]: 8: Hoare triple {1589#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1590#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:53,010 INFO L273 TraceCheckUtils]: 9: Hoare triple {1590#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1591#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:53,011 INFO L273 TraceCheckUtils]: 10: Hoare triple {1591#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1592#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:53,012 INFO L273 TraceCheckUtils]: 11: Hoare triple {1592#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1593#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:53,012 INFO L273 TraceCheckUtils]: 12: Hoare triple {1593#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1594#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:53,014 INFO L273 TraceCheckUtils]: 13: Hoare triple {1594#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1595#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:53,016 INFO L273 TraceCheckUtils]: 14: Hoare triple {1595#(<= main_~i~0 8)} assume !(~i~0 < 100000); {1586#false} is VALID [2018-11-23 12:09:53,016 INFO L273 TraceCheckUtils]: 15: Hoare triple {1586#false} havoc ~x~0;~x~0 := 0; {1586#false} is VALID [2018-11-23 12:09:53,016 INFO L273 TraceCheckUtils]: 16: Hoare triple {1586#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {1586#false} is VALID [2018-11-23 12:09:53,017 INFO L256 TraceCheckUtils]: 17: Hoare triple {1586#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {1586#false} is VALID [2018-11-23 12:09:53,017 INFO L273 TraceCheckUtils]: 18: Hoare triple {1586#false} ~cond := #in~cond; {1586#false} is VALID [2018-11-23 12:09:53,017 INFO L273 TraceCheckUtils]: 19: Hoare triple {1586#false} assume 0 == ~cond; {1586#false} is VALID [2018-11-23 12:09:53,017 INFO L273 TraceCheckUtils]: 20: Hoare triple {1586#false} assume !false; {1586#false} is VALID [2018-11-23 12:09:53,018 INFO L134 CoverageAnalysis]: Checked inductivity of 36 backedges. 0 proven. 36 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:53,018 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:53,019 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 9 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 9 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:53,031 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:09:53,080 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:09:53,080 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:53,106 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:53,107 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:53,700 INFO L256 TraceCheckUtils]: 0: Hoare triple {1585#true} call ULTIMATE.init(); {1585#true} is VALID [2018-11-23 12:09:53,701 INFO L273 TraceCheckUtils]: 1: Hoare triple {1585#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1585#true} is VALID [2018-11-23 12:09:53,701 INFO L273 TraceCheckUtils]: 2: Hoare triple {1585#true} assume true; {1585#true} is VALID [2018-11-23 12:09:53,701 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1585#true} {1585#true} #48#return; {1585#true} is VALID [2018-11-23 12:09:53,701 INFO L256 TraceCheckUtils]: 4: Hoare triple {1585#true} call #t~ret6 := main(); {1585#true} is VALID [2018-11-23 12:09:53,702 INFO L273 TraceCheckUtils]: 5: Hoare triple {1585#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {1614#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:53,703 INFO L273 TraceCheckUtils]: 6: Hoare triple {1614#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1588#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:53,703 INFO L273 TraceCheckUtils]: 7: Hoare triple {1588#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1589#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:53,705 INFO L273 TraceCheckUtils]: 8: Hoare triple {1589#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1590#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:53,706 INFO L273 TraceCheckUtils]: 9: Hoare triple {1590#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1591#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:53,707 INFO L273 TraceCheckUtils]: 10: Hoare triple {1591#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1592#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:53,708 INFO L273 TraceCheckUtils]: 11: Hoare triple {1592#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1593#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:53,709 INFO L273 TraceCheckUtils]: 12: Hoare triple {1593#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1594#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:53,710 INFO L273 TraceCheckUtils]: 13: Hoare triple {1594#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1595#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:53,711 INFO L273 TraceCheckUtils]: 14: Hoare triple {1595#(<= main_~i~0 8)} assume !(~i~0 < 100000); {1586#false} is VALID [2018-11-23 12:09:53,711 INFO L273 TraceCheckUtils]: 15: Hoare triple {1586#false} havoc ~x~0;~x~0 := 0; {1586#false} is VALID [2018-11-23 12:09:53,712 INFO L273 TraceCheckUtils]: 16: Hoare triple {1586#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {1586#false} is VALID [2018-11-23 12:09:53,712 INFO L256 TraceCheckUtils]: 17: Hoare triple {1586#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {1586#false} is VALID [2018-11-23 12:09:53,712 INFO L273 TraceCheckUtils]: 18: Hoare triple {1586#false} ~cond := #in~cond; {1586#false} is VALID [2018-11-23 12:09:53,712 INFO L273 TraceCheckUtils]: 19: Hoare triple {1586#false} assume 0 == ~cond; {1586#false} is VALID [2018-11-23 12:09:53,713 INFO L273 TraceCheckUtils]: 20: Hoare triple {1586#false} assume !false; {1586#false} is VALID [2018-11-23 12:09:53,713 INFO L134 CoverageAnalysis]: Checked inductivity of 36 backedges. 0 proven. 36 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:53,733 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:53,733 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [11, 11] total 12 [2018-11-23 12:09:53,734 INFO L78 Accepts]: Start accepts. Automaton has 12 states. Word has length 21 [2018-11-23 12:09:53,734 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:53,734 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 12 states. [2018-11-23 12:09:53,755 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 23 edges. 23 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:53,756 INFO L459 AbstractCegarLoop]: Interpolant automaton has 12 states [2018-11-23 12:09:53,756 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 12 interpolants. [2018-11-23 12:09:53,756 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=66, Invalid=66, Unknown=0, NotChecked=0, Total=132 [2018-11-23 12:09:53,757 INFO L87 Difference]: Start difference. First operand 26 states and 27 transitions. Second operand 12 states. [2018-11-23 12:09:54,183 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:54,184 INFO L93 Difference]: Finished difference Result 38 states and 40 transitions. [2018-11-23 12:09:54,184 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 11 states. [2018-11-23 12:09:54,184 INFO L78 Accepts]: Start accepts. Automaton has 12 states. Word has length 21 [2018-11-23 12:09:54,184 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:54,184 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 12 states. [2018-11-23 12:09:54,186 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 11 states to 11 states and 40 transitions. [2018-11-23 12:09:54,186 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 12 states. [2018-11-23 12:09:54,187 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 11 states to 11 states and 40 transitions. [2018-11-23 12:09:54,187 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 11 states and 40 transitions. [2018-11-23 12:09:54,227 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 40 edges. 40 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:54,228 INFO L225 Difference]: With dead ends: 38 [2018-11-23 12:09:54,228 INFO L226 Difference]: Without dead ends: 27 [2018-11-23 12:09:54,229 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 31 GetRequests, 21 SyntacticMatches, 0 SemanticMatches, 10 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 14 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=66, Invalid=66, Unknown=0, NotChecked=0, Total=132 [2018-11-23 12:09:54,229 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 27 states. [2018-11-23 12:09:54,250 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 27 to 27. [2018-11-23 12:09:54,250 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:54,250 INFO L82 GeneralOperation]: Start isEquivalent. First operand 27 states. Second operand 27 states. [2018-11-23 12:09:54,250 INFO L74 IsIncluded]: Start isIncluded. First operand 27 states. Second operand 27 states. [2018-11-23 12:09:54,250 INFO L87 Difference]: Start difference. First operand 27 states. Second operand 27 states. [2018-11-23 12:09:54,251 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:54,251 INFO L93 Difference]: Finished difference Result 27 states and 28 transitions. [2018-11-23 12:09:54,251 INFO L276 IsEmpty]: Start isEmpty. Operand 27 states and 28 transitions. [2018-11-23 12:09:54,252 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:54,252 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:54,252 INFO L74 IsIncluded]: Start isIncluded. First operand 27 states. Second operand 27 states. [2018-11-23 12:09:54,252 INFO L87 Difference]: Start difference. First operand 27 states. Second operand 27 states. [2018-11-23 12:09:54,252 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:54,253 INFO L93 Difference]: Finished difference Result 27 states and 28 transitions. [2018-11-23 12:09:54,253 INFO L276 IsEmpty]: Start isEmpty. Operand 27 states and 28 transitions. [2018-11-23 12:09:54,253 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:54,253 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:54,253 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:54,253 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:54,253 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 27 states. [2018-11-23 12:09:54,254 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 27 states to 27 states and 28 transitions. [2018-11-23 12:09:54,254 INFO L78 Accepts]: Start accepts. Automaton has 27 states and 28 transitions. Word has length 21 [2018-11-23 12:09:54,255 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:54,255 INFO L480 AbstractCegarLoop]: Abstraction has 27 states and 28 transitions. [2018-11-23 12:09:54,255 INFO L481 AbstractCegarLoop]: Interpolant automaton has 12 states. [2018-11-23 12:09:54,255 INFO L276 IsEmpty]: Start isEmpty. Operand 27 states and 28 transitions. [2018-11-23 12:09:54,255 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 23 [2018-11-23 12:09:54,255 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:54,256 INFO L402 BasicCegarLoop]: trace histogram [9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:54,256 INFO L423 AbstractCegarLoop]: === Iteration 11 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:54,256 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:54,256 INFO L82 PathProgramCache]: Analyzing trace with hash -1641439122, now seen corresponding path program 9 times [2018-11-23 12:09:54,256 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:54,256 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:54,257 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:54,257 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:54,257 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:54,273 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:54,525 INFO L256 TraceCheckUtils]: 0: Hoare triple {1815#true} call ULTIMATE.init(); {1815#true} is VALID [2018-11-23 12:09:54,525 INFO L273 TraceCheckUtils]: 1: Hoare triple {1815#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1815#true} is VALID [2018-11-23 12:09:54,526 INFO L273 TraceCheckUtils]: 2: Hoare triple {1815#true} assume true; {1815#true} is VALID [2018-11-23 12:09:54,526 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1815#true} {1815#true} #48#return; {1815#true} is VALID [2018-11-23 12:09:54,526 INFO L256 TraceCheckUtils]: 4: Hoare triple {1815#true} call #t~ret6 := main(); {1815#true} is VALID [2018-11-23 12:09:54,528 INFO L273 TraceCheckUtils]: 5: Hoare triple {1815#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {1817#(= main_~i~0 0)} is VALID [2018-11-23 12:09:54,529 INFO L273 TraceCheckUtils]: 6: Hoare triple {1817#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1818#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:54,529 INFO L273 TraceCheckUtils]: 7: Hoare triple {1818#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1819#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:54,530 INFO L273 TraceCheckUtils]: 8: Hoare triple {1819#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1820#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:54,531 INFO L273 TraceCheckUtils]: 9: Hoare triple {1820#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1821#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:54,532 INFO L273 TraceCheckUtils]: 10: Hoare triple {1821#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1822#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:54,533 INFO L273 TraceCheckUtils]: 11: Hoare triple {1822#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1823#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:54,535 INFO L273 TraceCheckUtils]: 12: Hoare triple {1823#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1824#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:54,536 INFO L273 TraceCheckUtils]: 13: Hoare triple {1824#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1825#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:54,537 INFO L273 TraceCheckUtils]: 14: Hoare triple {1825#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1826#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:54,538 INFO L273 TraceCheckUtils]: 15: Hoare triple {1826#(<= main_~i~0 9)} assume !(~i~0 < 100000); {1816#false} is VALID [2018-11-23 12:09:54,538 INFO L273 TraceCheckUtils]: 16: Hoare triple {1816#false} havoc ~x~0;~x~0 := 0; {1816#false} is VALID [2018-11-23 12:09:54,538 INFO L273 TraceCheckUtils]: 17: Hoare triple {1816#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {1816#false} is VALID [2018-11-23 12:09:54,538 INFO L256 TraceCheckUtils]: 18: Hoare triple {1816#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {1816#false} is VALID [2018-11-23 12:09:54,539 INFO L273 TraceCheckUtils]: 19: Hoare triple {1816#false} ~cond := #in~cond; {1816#false} is VALID [2018-11-23 12:09:54,539 INFO L273 TraceCheckUtils]: 20: Hoare triple {1816#false} assume 0 == ~cond; {1816#false} is VALID [2018-11-23 12:09:54,539 INFO L273 TraceCheckUtils]: 21: Hoare triple {1816#false} assume !false; {1816#false} is VALID [2018-11-23 12:09:54,540 INFO L134 CoverageAnalysis]: Checked inductivity of 45 backedges. 0 proven. 45 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:54,541 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:54,541 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:54,554 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:09:54,652 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 6 check-sat command(s) [2018-11-23 12:09:54,653 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:54,661 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:54,663 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:54,806 INFO L256 TraceCheckUtils]: 0: Hoare triple {1815#true} call ULTIMATE.init(); {1815#true} is VALID [2018-11-23 12:09:54,806 INFO L273 TraceCheckUtils]: 1: Hoare triple {1815#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {1815#true} is VALID [2018-11-23 12:09:54,807 INFO L273 TraceCheckUtils]: 2: Hoare triple {1815#true} assume true; {1815#true} is VALID [2018-11-23 12:09:54,807 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {1815#true} {1815#true} #48#return; {1815#true} is VALID [2018-11-23 12:09:54,807 INFO L256 TraceCheckUtils]: 4: Hoare triple {1815#true} call #t~ret6 := main(); {1815#true} is VALID [2018-11-23 12:09:54,809 INFO L273 TraceCheckUtils]: 5: Hoare triple {1815#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {1845#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:54,810 INFO L273 TraceCheckUtils]: 6: Hoare triple {1845#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1818#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:54,812 INFO L273 TraceCheckUtils]: 7: Hoare triple {1818#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1819#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:54,813 INFO L273 TraceCheckUtils]: 8: Hoare triple {1819#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1820#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:54,820 INFO L273 TraceCheckUtils]: 9: Hoare triple {1820#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1821#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:54,821 INFO L273 TraceCheckUtils]: 10: Hoare triple {1821#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1822#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:54,823 INFO L273 TraceCheckUtils]: 11: Hoare triple {1822#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1823#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:54,824 INFO L273 TraceCheckUtils]: 12: Hoare triple {1823#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1824#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:54,825 INFO L273 TraceCheckUtils]: 13: Hoare triple {1824#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1825#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:54,825 INFO L273 TraceCheckUtils]: 14: Hoare triple {1825#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {1826#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:54,826 INFO L273 TraceCheckUtils]: 15: Hoare triple {1826#(<= main_~i~0 9)} assume !(~i~0 < 100000); {1816#false} is VALID [2018-11-23 12:09:54,826 INFO L273 TraceCheckUtils]: 16: Hoare triple {1816#false} havoc ~x~0;~x~0 := 0; {1816#false} is VALID [2018-11-23 12:09:54,827 INFO L273 TraceCheckUtils]: 17: Hoare triple {1816#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {1816#false} is VALID [2018-11-23 12:09:54,827 INFO L256 TraceCheckUtils]: 18: Hoare triple {1816#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {1816#false} is VALID [2018-11-23 12:09:54,827 INFO L273 TraceCheckUtils]: 19: Hoare triple {1816#false} ~cond := #in~cond; {1816#false} is VALID [2018-11-23 12:09:54,828 INFO L273 TraceCheckUtils]: 20: Hoare triple {1816#false} assume 0 == ~cond; {1816#false} is VALID [2018-11-23 12:09:54,828 INFO L273 TraceCheckUtils]: 21: Hoare triple {1816#false} assume !false; {1816#false} is VALID [2018-11-23 12:09:54,829 INFO L134 CoverageAnalysis]: Checked inductivity of 45 backedges. 0 proven. 45 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:54,850 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:54,850 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [12, 12] total 13 [2018-11-23 12:09:54,851 INFO L78 Accepts]: Start accepts. Automaton has 13 states. Word has length 22 [2018-11-23 12:09:54,851 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:54,851 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 13 states. [2018-11-23 12:09:54,875 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 24 edges. 24 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:54,875 INFO L459 AbstractCegarLoop]: Interpolant automaton has 13 states [2018-11-23 12:09:54,876 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 13 interpolants. [2018-11-23 12:09:54,876 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=78, Invalid=78, Unknown=0, NotChecked=0, Total=156 [2018-11-23 12:09:54,877 INFO L87 Difference]: Start difference. First operand 27 states and 28 transitions. Second operand 13 states. [2018-11-23 12:09:55,047 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:55,048 INFO L93 Difference]: Finished difference Result 39 states and 41 transitions. [2018-11-23 12:09:55,048 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 12 states. [2018-11-23 12:09:55,048 INFO L78 Accepts]: Start accepts. Automaton has 13 states. Word has length 22 [2018-11-23 12:09:55,048 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:55,049 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 13 states. [2018-11-23 12:09:55,050 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 12 states to 12 states and 41 transitions. [2018-11-23 12:09:55,050 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 13 states. [2018-11-23 12:09:55,051 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 12 states to 12 states and 41 transitions. [2018-11-23 12:09:55,051 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 12 states and 41 transitions. [2018-11-23 12:09:55,089 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 41 edges. 41 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:55,090 INFO L225 Difference]: With dead ends: 39 [2018-11-23 12:09:55,091 INFO L226 Difference]: Without dead ends: 28 [2018-11-23 12:09:55,091 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 33 GetRequests, 22 SyntacticMatches, 0 SemanticMatches, 11 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 16 ImplicationChecksByTransitivity, 0.1s TimeCoverageRelationStatistics Valid=78, Invalid=78, Unknown=0, NotChecked=0, Total=156 [2018-11-23 12:09:55,092 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 28 states. [2018-11-23 12:09:55,107 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 28 to 28. [2018-11-23 12:09:55,108 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:55,108 INFO L82 GeneralOperation]: Start isEquivalent. First operand 28 states. Second operand 28 states. [2018-11-23 12:09:55,108 INFO L74 IsIncluded]: Start isIncluded. First operand 28 states. Second operand 28 states. [2018-11-23 12:09:55,108 INFO L87 Difference]: Start difference. First operand 28 states. Second operand 28 states. [2018-11-23 12:09:55,109 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:55,109 INFO L93 Difference]: Finished difference Result 28 states and 29 transitions. [2018-11-23 12:09:55,109 INFO L276 IsEmpty]: Start isEmpty. Operand 28 states and 29 transitions. [2018-11-23 12:09:55,109 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:55,109 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:55,109 INFO L74 IsIncluded]: Start isIncluded. First operand 28 states. Second operand 28 states. [2018-11-23 12:09:55,109 INFO L87 Difference]: Start difference. First operand 28 states. Second operand 28 states. [2018-11-23 12:09:55,110 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:55,110 INFO L93 Difference]: Finished difference Result 28 states and 29 transitions. [2018-11-23 12:09:55,110 INFO L276 IsEmpty]: Start isEmpty. Operand 28 states and 29 transitions. [2018-11-23 12:09:55,110 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:55,110 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:55,111 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:55,111 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:55,111 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 28 states. [2018-11-23 12:09:55,111 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 28 states to 28 states and 29 transitions. [2018-11-23 12:09:55,112 INFO L78 Accepts]: Start accepts. Automaton has 28 states and 29 transitions. Word has length 22 [2018-11-23 12:09:55,112 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:55,112 INFO L480 AbstractCegarLoop]: Abstraction has 28 states and 29 transitions. [2018-11-23 12:09:55,112 INFO L481 AbstractCegarLoop]: Interpolant automaton has 13 states. [2018-11-23 12:09:55,112 INFO L276 IsEmpty]: Start isEmpty. Operand 28 states and 29 transitions. [2018-11-23 12:09:55,112 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 24 [2018-11-23 12:09:55,113 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:55,113 INFO L402 BasicCegarLoop]: trace histogram [10, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:55,113 INFO L423 AbstractCegarLoop]: === Iteration 12 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:55,113 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:55,113 INFO L82 PathProgramCache]: Analyzing trace with hash -1436083918, now seen corresponding path program 10 times [2018-11-23 12:09:55,113 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:55,114 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:55,114 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:55,114 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:55,115 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:55,130 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:55,391 INFO L256 TraceCheckUtils]: 0: Hoare triple {2055#true} call ULTIMATE.init(); {2055#true} is VALID [2018-11-23 12:09:55,392 INFO L273 TraceCheckUtils]: 1: Hoare triple {2055#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {2055#true} is VALID [2018-11-23 12:09:55,392 INFO L273 TraceCheckUtils]: 2: Hoare triple {2055#true} assume true; {2055#true} is VALID [2018-11-23 12:09:55,392 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2055#true} {2055#true} #48#return; {2055#true} is VALID [2018-11-23 12:09:55,392 INFO L256 TraceCheckUtils]: 4: Hoare triple {2055#true} call #t~ret6 := main(); {2055#true} is VALID [2018-11-23 12:09:55,393 INFO L273 TraceCheckUtils]: 5: Hoare triple {2055#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {2057#(= main_~i~0 0)} is VALID [2018-11-23 12:09:55,394 INFO L273 TraceCheckUtils]: 6: Hoare triple {2057#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2058#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:55,395 INFO L273 TraceCheckUtils]: 7: Hoare triple {2058#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2059#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:55,395 INFO L273 TraceCheckUtils]: 8: Hoare triple {2059#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2060#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:55,396 INFO L273 TraceCheckUtils]: 9: Hoare triple {2060#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2061#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:55,397 INFO L273 TraceCheckUtils]: 10: Hoare triple {2061#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2062#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:55,398 INFO L273 TraceCheckUtils]: 11: Hoare triple {2062#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2063#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:55,399 INFO L273 TraceCheckUtils]: 12: Hoare triple {2063#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2064#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:55,400 INFO L273 TraceCheckUtils]: 13: Hoare triple {2064#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2065#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:55,401 INFO L273 TraceCheckUtils]: 14: Hoare triple {2065#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2066#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:55,402 INFO L273 TraceCheckUtils]: 15: Hoare triple {2066#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2067#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:55,403 INFO L273 TraceCheckUtils]: 16: Hoare triple {2067#(<= main_~i~0 10)} assume !(~i~0 < 100000); {2056#false} is VALID [2018-11-23 12:09:55,403 INFO L273 TraceCheckUtils]: 17: Hoare triple {2056#false} havoc ~x~0;~x~0 := 0; {2056#false} is VALID [2018-11-23 12:09:55,403 INFO L273 TraceCheckUtils]: 18: Hoare triple {2056#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {2056#false} is VALID [2018-11-23 12:09:55,404 INFO L256 TraceCheckUtils]: 19: Hoare triple {2056#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {2056#false} is VALID [2018-11-23 12:09:55,404 INFO L273 TraceCheckUtils]: 20: Hoare triple {2056#false} ~cond := #in~cond; {2056#false} is VALID [2018-11-23 12:09:55,404 INFO L273 TraceCheckUtils]: 21: Hoare triple {2056#false} assume 0 == ~cond; {2056#false} is VALID [2018-11-23 12:09:55,404 INFO L273 TraceCheckUtils]: 22: Hoare triple {2056#false} assume !false; {2056#false} is VALID [2018-11-23 12:09:55,406 INFO L134 CoverageAnalysis]: Checked inductivity of 55 backedges. 0 proven. 55 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:55,406 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:55,406 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 11 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 11 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:09:55,426 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:09:55,450 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:09:55,450 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:55,481 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:55,482 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:55,613 INFO L256 TraceCheckUtils]: 0: Hoare triple {2055#true} call ULTIMATE.init(); {2055#true} is VALID [2018-11-23 12:09:55,613 INFO L273 TraceCheckUtils]: 1: Hoare triple {2055#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {2055#true} is VALID [2018-11-23 12:09:55,613 INFO L273 TraceCheckUtils]: 2: Hoare triple {2055#true} assume true; {2055#true} is VALID [2018-11-23 12:09:55,613 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2055#true} {2055#true} #48#return; {2055#true} is VALID [2018-11-23 12:09:55,613 INFO L256 TraceCheckUtils]: 4: Hoare triple {2055#true} call #t~ret6 := main(); {2055#true} is VALID [2018-11-23 12:09:55,615 INFO L273 TraceCheckUtils]: 5: Hoare triple {2055#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {2086#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:55,616 INFO L273 TraceCheckUtils]: 6: Hoare triple {2086#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2058#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:55,617 INFO L273 TraceCheckUtils]: 7: Hoare triple {2058#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2059#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:55,618 INFO L273 TraceCheckUtils]: 8: Hoare triple {2059#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2060#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:55,619 INFO L273 TraceCheckUtils]: 9: Hoare triple {2060#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2061#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:55,620 INFO L273 TraceCheckUtils]: 10: Hoare triple {2061#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2062#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:55,637 INFO L273 TraceCheckUtils]: 11: Hoare triple {2062#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2063#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:55,638 INFO L273 TraceCheckUtils]: 12: Hoare triple {2063#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2064#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:55,638 INFO L273 TraceCheckUtils]: 13: Hoare triple {2064#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2065#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:55,639 INFO L273 TraceCheckUtils]: 14: Hoare triple {2065#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2066#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:55,659 INFO L273 TraceCheckUtils]: 15: Hoare triple {2066#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2067#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:55,672 INFO L273 TraceCheckUtils]: 16: Hoare triple {2067#(<= main_~i~0 10)} assume !(~i~0 < 100000); {2056#false} is VALID [2018-11-23 12:09:55,672 INFO L273 TraceCheckUtils]: 17: Hoare triple {2056#false} havoc ~x~0;~x~0 := 0; {2056#false} is VALID [2018-11-23 12:09:55,672 INFO L273 TraceCheckUtils]: 18: Hoare triple {2056#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {2056#false} is VALID [2018-11-23 12:09:55,673 INFO L256 TraceCheckUtils]: 19: Hoare triple {2056#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {2056#false} is VALID [2018-11-23 12:09:55,673 INFO L273 TraceCheckUtils]: 20: Hoare triple {2056#false} ~cond := #in~cond; {2056#false} is VALID [2018-11-23 12:09:55,673 INFO L273 TraceCheckUtils]: 21: Hoare triple {2056#false} assume 0 == ~cond; {2056#false} is VALID [2018-11-23 12:09:55,673 INFO L273 TraceCheckUtils]: 22: Hoare triple {2056#false} assume !false; {2056#false} is VALID [2018-11-23 12:09:55,674 INFO L134 CoverageAnalysis]: Checked inductivity of 55 backedges. 0 proven. 55 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:55,703 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:55,703 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [13, 13] total 14 [2018-11-23 12:09:55,704 INFO L78 Accepts]: Start accepts. Automaton has 14 states. Word has length 23 [2018-11-23 12:09:55,704 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:55,704 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 14 states. [2018-11-23 12:09:55,779 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 25 edges. 25 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:55,779 INFO L459 AbstractCegarLoop]: Interpolant automaton has 14 states [2018-11-23 12:09:55,779 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 14 interpolants. [2018-11-23 12:09:55,780 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=91, Invalid=91, Unknown=0, NotChecked=0, Total=182 [2018-11-23 12:09:55,780 INFO L87 Difference]: Start difference. First operand 28 states and 29 transitions. Second operand 14 states. [2018-11-23 12:09:55,930 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:55,930 INFO L93 Difference]: Finished difference Result 40 states and 42 transitions. [2018-11-23 12:09:55,930 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 13 states. [2018-11-23 12:09:55,930 INFO L78 Accepts]: Start accepts. Automaton has 14 states. Word has length 23 [2018-11-23 12:09:55,931 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:55,931 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 14 states. [2018-11-23 12:09:55,932 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 13 states to 13 states and 42 transitions. [2018-11-23 12:09:55,932 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 14 states. [2018-11-23 12:09:55,933 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 13 states to 13 states and 42 transitions. [2018-11-23 12:09:55,933 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 13 states and 42 transitions. [2018-11-23 12:09:55,969 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:55,970 INFO L225 Difference]: With dead ends: 40 [2018-11-23 12:09:55,970 INFO L226 Difference]: Without dead ends: 29 [2018-11-23 12:09:55,971 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 35 GetRequests, 23 SyntacticMatches, 0 SemanticMatches, 12 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 18 ImplicationChecksByTransitivity, 0.1s TimeCoverageRelationStatistics Valid=91, Invalid=91, Unknown=0, NotChecked=0, Total=182 [2018-11-23 12:09:55,971 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 29 states. [2018-11-23 12:09:55,991 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 29 to 29. [2018-11-23 12:09:55,991 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:55,991 INFO L82 GeneralOperation]: Start isEquivalent. First operand 29 states. Second operand 29 states. [2018-11-23 12:09:55,991 INFO L74 IsIncluded]: Start isIncluded. First operand 29 states. Second operand 29 states. [2018-11-23 12:09:55,992 INFO L87 Difference]: Start difference. First operand 29 states. Second operand 29 states. [2018-11-23 12:09:55,993 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:55,993 INFO L93 Difference]: Finished difference Result 29 states and 30 transitions. [2018-11-23 12:09:55,994 INFO L276 IsEmpty]: Start isEmpty. Operand 29 states and 30 transitions. [2018-11-23 12:09:55,994 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:55,994 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:55,994 INFO L74 IsIncluded]: Start isIncluded. First operand 29 states. Second operand 29 states. [2018-11-23 12:09:55,995 INFO L87 Difference]: Start difference. First operand 29 states. Second operand 29 states. [2018-11-23 12:09:55,995 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:55,995 INFO L93 Difference]: Finished difference Result 29 states and 30 transitions. [2018-11-23 12:09:55,996 INFO L276 IsEmpty]: Start isEmpty. Operand 29 states and 30 transitions. [2018-11-23 12:09:55,996 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:55,996 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:55,996 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:55,996 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:55,996 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 29 states. [2018-11-23 12:09:55,997 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 29 states to 29 states and 30 transitions. [2018-11-23 12:09:55,997 INFO L78 Accepts]: Start accepts. Automaton has 29 states and 30 transitions. Word has length 23 [2018-11-23 12:09:55,997 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:55,997 INFO L480 AbstractCegarLoop]: Abstraction has 29 states and 30 transitions. [2018-11-23 12:09:55,997 INFO L481 AbstractCegarLoop]: Interpolant automaton has 14 states. [2018-11-23 12:09:55,997 INFO L276 IsEmpty]: Start isEmpty. Operand 29 states and 30 transitions. [2018-11-23 12:09:55,997 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 25 [2018-11-23 12:09:55,998 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:55,998 INFO L402 BasicCegarLoop]: trace histogram [11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:55,998 INFO L423 AbstractCegarLoop]: === Iteration 13 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:55,998 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:55,998 INFO L82 PathProgramCache]: Analyzing trace with hash 634960110, now seen corresponding path program 11 times [2018-11-23 12:09:55,998 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:55,999 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:55,999 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:55,999 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:55,999 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:56,014 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:56,307 INFO L256 TraceCheckUtils]: 0: Hoare triple {2305#true} call ULTIMATE.init(); {2305#true} is VALID [2018-11-23 12:09:56,307 INFO L273 TraceCheckUtils]: 1: Hoare triple {2305#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {2305#true} is VALID [2018-11-23 12:09:56,307 INFO L273 TraceCheckUtils]: 2: Hoare triple {2305#true} assume true; {2305#true} is VALID [2018-11-23 12:09:56,308 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2305#true} {2305#true} #48#return; {2305#true} is VALID [2018-11-23 12:09:56,308 INFO L256 TraceCheckUtils]: 4: Hoare triple {2305#true} call #t~ret6 := main(); {2305#true} is VALID [2018-11-23 12:09:56,309 INFO L273 TraceCheckUtils]: 5: Hoare triple {2305#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {2307#(= main_~i~0 0)} is VALID [2018-11-23 12:09:56,310 INFO L273 TraceCheckUtils]: 6: Hoare triple {2307#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2308#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:56,310 INFO L273 TraceCheckUtils]: 7: Hoare triple {2308#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2309#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:56,311 INFO L273 TraceCheckUtils]: 8: Hoare triple {2309#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2310#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:56,312 INFO L273 TraceCheckUtils]: 9: Hoare triple {2310#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2311#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:56,312 INFO L273 TraceCheckUtils]: 10: Hoare triple {2311#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2312#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:56,313 INFO L273 TraceCheckUtils]: 11: Hoare triple {2312#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2313#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:56,315 INFO L273 TraceCheckUtils]: 12: Hoare triple {2313#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2314#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:56,316 INFO L273 TraceCheckUtils]: 13: Hoare triple {2314#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2315#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:56,317 INFO L273 TraceCheckUtils]: 14: Hoare triple {2315#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2316#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:56,318 INFO L273 TraceCheckUtils]: 15: Hoare triple {2316#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2317#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:56,320 INFO L273 TraceCheckUtils]: 16: Hoare triple {2317#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2318#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:56,320 INFO L273 TraceCheckUtils]: 17: Hoare triple {2318#(<= main_~i~0 11)} assume !(~i~0 < 100000); {2306#false} is VALID [2018-11-23 12:09:56,321 INFO L273 TraceCheckUtils]: 18: Hoare triple {2306#false} havoc ~x~0;~x~0 := 0; {2306#false} is VALID [2018-11-23 12:09:56,321 INFO L273 TraceCheckUtils]: 19: Hoare triple {2306#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {2306#false} is VALID [2018-11-23 12:09:56,321 INFO L256 TraceCheckUtils]: 20: Hoare triple {2306#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {2306#false} is VALID [2018-11-23 12:09:56,322 INFO L273 TraceCheckUtils]: 21: Hoare triple {2306#false} ~cond := #in~cond; {2306#false} is VALID [2018-11-23 12:09:56,322 INFO L273 TraceCheckUtils]: 22: Hoare triple {2306#false} assume 0 == ~cond; {2306#false} is VALID [2018-11-23 12:09:56,322 INFO L273 TraceCheckUtils]: 23: Hoare triple {2306#false} assume !false; {2306#false} is VALID [2018-11-23 12:09:56,323 INFO L134 CoverageAnalysis]: Checked inductivity of 66 backedges. 0 proven. 66 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:56,324 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:56,324 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:56,340 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:09:56,446 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 7 check-sat command(s) [2018-11-23 12:09:56,446 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:56,461 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:56,462 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:56,680 INFO L256 TraceCheckUtils]: 0: Hoare triple {2305#true} call ULTIMATE.init(); {2305#true} is VALID [2018-11-23 12:09:56,680 INFO L273 TraceCheckUtils]: 1: Hoare triple {2305#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {2305#true} is VALID [2018-11-23 12:09:56,680 INFO L273 TraceCheckUtils]: 2: Hoare triple {2305#true} assume true; {2305#true} is VALID [2018-11-23 12:09:56,680 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2305#true} {2305#true} #48#return; {2305#true} is VALID [2018-11-23 12:09:56,680 INFO L256 TraceCheckUtils]: 4: Hoare triple {2305#true} call #t~ret6 := main(); {2305#true} is VALID [2018-11-23 12:09:56,681 INFO L273 TraceCheckUtils]: 5: Hoare triple {2305#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {2337#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:56,683 INFO L273 TraceCheckUtils]: 6: Hoare triple {2337#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2308#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:56,683 INFO L273 TraceCheckUtils]: 7: Hoare triple {2308#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2309#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:56,684 INFO L273 TraceCheckUtils]: 8: Hoare triple {2309#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2310#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:56,686 INFO L273 TraceCheckUtils]: 9: Hoare triple {2310#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2311#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:56,687 INFO L273 TraceCheckUtils]: 10: Hoare triple {2311#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2312#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:56,688 INFO L273 TraceCheckUtils]: 11: Hoare triple {2312#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2313#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:56,689 INFO L273 TraceCheckUtils]: 12: Hoare triple {2313#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2314#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:56,693 INFO L273 TraceCheckUtils]: 13: Hoare triple {2314#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2315#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:56,694 INFO L273 TraceCheckUtils]: 14: Hoare triple {2315#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2316#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:56,694 INFO L273 TraceCheckUtils]: 15: Hoare triple {2316#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2317#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:56,695 INFO L273 TraceCheckUtils]: 16: Hoare triple {2317#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2318#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:56,695 INFO L273 TraceCheckUtils]: 17: Hoare triple {2318#(<= main_~i~0 11)} assume !(~i~0 < 100000); {2306#false} is VALID [2018-11-23 12:09:56,696 INFO L273 TraceCheckUtils]: 18: Hoare triple {2306#false} havoc ~x~0;~x~0 := 0; {2306#false} is VALID [2018-11-23 12:09:56,696 INFO L273 TraceCheckUtils]: 19: Hoare triple {2306#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {2306#false} is VALID [2018-11-23 12:09:56,696 INFO L256 TraceCheckUtils]: 20: Hoare triple {2306#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {2306#false} is VALID [2018-11-23 12:09:56,696 INFO L273 TraceCheckUtils]: 21: Hoare triple {2306#false} ~cond := #in~cond; {2306#false} is VALID [2018-11-23 12:09:56,696 INFO L273 TraceCheckUtils]: 22: Hoare triple {2306#false} assume 0 == ~cond; {2306#false} is VALID [2018-11-23 12:09:56,696 INFO L273 TraceCheckUtils]: 23: Hoare triple {2306#false} assume !false; {2306#false} is VALID [2018-11-23 12:09:56,697 INFO L134 CoverageAnalysis]: Checked inductivity of 66 backedges. 0 proven. 66 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:56,717 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:56,717 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [14, 14] total 15 [2018-11-23 12:09:56,718 INFO L78 Accepts]: Start accepts. Automaton has 15 states. Word has length 24 [2018-11-23 12:09:56,718 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:56,718 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 15 states. [2018-11-23 12:09:56,739 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 26 edges. 26 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:56,740 INFO L459 AbstractCegarLoop]: Interpolant automaton has 15 states [2018-11-23 12:09:56,740 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 15 interpolants. [2018-11-23 12:09:56,740 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=105, Invalid=105, Unknown=0, NotChecked=0, Total=210 [2018-11-23 12:09:56,741 INFO L87 Difference]: Start difference. First operand 29 states and 30 transitions. Second operand 15 states. [2018-11-23 12:09:57,014 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:57,014 INFO L93 Difference]: Finished difference Result 41 states and 43 transitions. [2018-11-23 12:09:57,014 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 14 states. [2018-11-23 12:09:57,015 INFO L78 Accepts]: Start accepts. Automaton has 15 states. Word has length 24 [2018-11-23 12:09:57,015 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:57,015 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 15 states. [2018-11-23 12:09:57,017 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 14 states to 14 states and 43 transitions. [2018-11-23 12:09:57,017 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 15 states. [2018-11-23 12:09:57,018 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 14 states to 14 states and 43 transitions. [2018-11-23 12:09:57,019 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 14 states and 43 transitions. [2018-11-23 12:09:57,073 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:57,074 INFO L225 Difference]: With dead ends: 41 [2018-11-23 12:09:57,074 INFO L226 Difference]: Without dead ends: 30 [2018-11-23 12:09:57,075 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 37 GetRequests, 24 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:57,075 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 30 states. [2018-11-23 12:09:57,095 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 30 to 30. [2018-11-23 12:09:57,095 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:57,095 INFO L82 GeneralOperation]: Start isEquivalent. First operand 30 states. Second operand 30 states. [2018-11-23 12:09:57,095 INFO L74 IsIncluded]: Start isIncluded. First operand 30 states. Second operand 30 states. [2018-11-23 12:09:57,096 INFO L87 Difference]: Start difference. First operand 30 states. Second operand 30 states. [2018-11-23 12:09:57,097 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:57,097 INFO L93 Difference]: Finished difference Result 30 states and 31 transitions. [2018-11-23 12:09:57,097 INFO L276 IsEmpty]: Start isEmpty. Operand 30 states and 31 transitions. [2018-11-23 12:09:57,098 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:57,098 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:57,098 INFO L74 IsIncluded]: Start isIncluded. First operand 30 states. Second operand 30 states. [2018-11-23 12:09:57,098 INFO L87 Difference]: Start difference. First operand 30 states. Second operand 30 states. [2018-11-23 12:09:57,099 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:57,099 INFO L93 Difference]: Finished difference Result 30 states and 31 transitions. [2018-11-23 12:09:57,099 INFO L276 IsEmpty]: Start isEmpty. Operand 30 states and 31 transitions. [2018-11-23 12:09:57,099 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:57,099 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:57,099 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:57,100 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:57,100 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 30 states. [2018-11-23 12:09:57,100 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 30 states to 30 states and 31 transitions. [2018-11-23 12:09:57,100 INFO L78 Accepts]: Start accepts. Automaton has 30 states and 31 transitions. Word has length 24 [2018-11-23 12:09:57,101 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:57,101 INFO L480 AbstractCegarLoop]: Abstraction has 30 states and 31 transitions. [2018-11-23 12:09:57,101 INFO L481 AbstractCegarLoop]: Interpolant automaton has 15 states. [2018-11-23 12:09:57,101 INFO L276 IsEmpty]: Start isEmpty. Operand 30 states and 31 transitions. [2018-11-23 12:09:57,101 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 26 [2018-11-23 12:09:57,101 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:57,101 INFO L402 BasicCegarLoop]: trace histogram [12, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:57,102 INFO L423 AbstractCegarLoop]: === Iteration 14 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:57,102 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:57,102 INFO L82 PathProgramCache]: Analyzing trace with hash 412815538, now seen corresponding path program 12 times [2018-11-23 12:09:57,102 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:57,102 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:57,103 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:57,103 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:57,103 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:57,118 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:58,015 INFO L256 TraceCheckUtils]: 0: Hoare triple {2565#true} call ULTIMATE.init(); {2565#true} is VALID [2018-11-23 12:09:58,015 INFO L273 TraceCheckUtils]: 1: Hoare triple {2565#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {2565#true} is VALID [2018-11-23 12:09:58,016 INFO L273 TraceCheckUtils]: 2: Hoare triple {2565#true} assume true; {2565#true} is VALID [2018-11-23 12:09:58,016 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2565#true} {2565#true} #48#return; {2565#true} is VALID [2018-11-23 12:09:58,016 INFO L256 TraceCheckUtils]: 4: Hoare triple {2565#true} call #t~ret6 := main(); {2565#true} is VALID [2018-11-23 12:09:58,017 INFO L273 TraceCheckUtils]: 5: Hoare triple {2565#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {2567#(= main_~i~0 0)} is VALID [2018-11-23 12:09:58,018 INFO L273 TraceCheckUtils]: 6: Hoare triple {2567#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2568#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:58,018 INFO L273 TraceCheckUtils]: 7: Hoare triple {2568#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2569#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:58,019 INFO L273 TraceCheckUtils]: 8: Hoare triple {2569#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2570#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:58,020 INFO L273 TraceCheckUtils]: 9: Hoare triple {2570#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2571#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:58,020 INFO L273 TraceCheckUtils]: 10: Hoare triple {2571#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2572#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:58,021 INFO L273 TraceCheckUtils]: 11: Hoare triple {2572#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2573#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:58,022 INFO L273 TraceCheckUtils]: 12: Hoare triple {2573#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2574#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:58,023 INFO L273 TraceCheckUtils]: 13: Hoare triple {2574#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2575#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:58,025 INFO L273 TraceCheckUtils]: 14: Hoare triple {2575#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2576#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:58,026 INFO L273 TraceCheckUtils]: 15: Hoare triple {2576#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2577#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:58,027 INFO L273 TraceCheckUtils]: 16: Hoare triple {2577#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2578#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:58,028 INFO L273 TraceCheckUtils]: 17: Hoare triple {2578#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2579#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:58,029 INFO L273 TraceCheckUtils]: 18: Hoare triple {2579#(<= main_~i~0 12)} assume !(~i~0 < 100000); {2566#false} is VALID [2018-11-23 12:09:58,029 INFO L273 TraceCheckUtils]: 19: Hoare triple {2566#false} havoc ~x~0;~x~0 := 0; {2566#false} is VALID [2018-11-23 12:09:58,029 INFO L273 TraceCheckUtils]: 20: Hoare triple {2566#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {2566#false} is VALID [2018-11-23 12:09:58,029 INFO L256 TraceCheckUtils]: 21: Hoare triple {2566#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {2566#false} is VALID [2018-11-23 12:09:58,030 INFO L273 TraceCheckUtils]: 22: Hoare triple {2566#false} ~cond := #in~cond; {2566#false} is VALID [2018-11-23 12:09:58,030 INFO L273 TraceCheckUtils]: 23: Hoare triple {2566#false} assume 0 == ~cond; {2566#false} is VALID [2018-11-23 12:09:58,030 INFO L273 TraceCheckUtils]: 24: Hoare triple {2566#false} assume !false; {2566#false} is VALID [2018-11-23 12:09:58,031 INFO L134 CoverageAnalysis]: Checked inductivity of 78 backedges. 0 proven. 78 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:58,031 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:58,031 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:58,041 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE [2018-11-23 12:09:58,137 INFO L249 tOrderPrioritization]: Assert order MIX_INSIDE_OUTSIDE issued 7 check-sat command(s) [2018-11-23 12:09:58,137 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:09:58,149 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:58,150 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:58,372 INFO L256 TraceCheckUtils]: 0: Hoare triple {2565#true} call ULTIMATE.init(); {2565#true} is VALID [2018-11-23 12:09:58,372 INFO L273 TraceCheckUtils]: 1: Hoare triple {2565#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {2565#true} is VALID [2018-11-23 12:09:58,372 INFO L273 TraceCheckUtils]: 2: Hoare triple {2565#true} assume true; {2565#true} is VALID [2018-11-23 12:09:58,373 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2565#true} {2565#true} #48#return; {2565#true} is VALID [2018-11-23 12:09:58,373 INFO L256 TraceCheckUtils]: 4: Hoare triple {2565#true} call #t~ret6 := main(); {2565#true} is VALID [2018-11-23 12:09:58,374 INFO L273 TraceCheckUtils]: 5: Hoare triple {2565#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {2598#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:58,374 INFO L273 TraceCheckUtils]: 6: Hoare triple {2598#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2568#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:58,375 INFO L273 TraceCheckUtils]: 7: Hoare triple {2568#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2569#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:58,380 INFO L273 TraceCheckUtils]: 8: Hoare triple {2569#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2570#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:58,383 INFO L273 TraceCheckUtils]: 9: Hoare triple {2570#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2571#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:58,384 INFO L273 TraceCheckUtils]: 10: Hoare triple {2571#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2572#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:58,386 INFO L273 TraceCheckUtils]: 11: Hoare triple {2572#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2573#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:58,386 INFO L273 TraceCheckUtils]: 12: Hoare triple {2573#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2574#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:58,388 INFO L273 TraceCheckUtils]: 13: Hoare triple {2574#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2575#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:58,390 INFO L273 TraceCheckUtils]: 14: Hoare triple {2575#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2576#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:58,391 INFO L273 TraceCheckUtils]: 15: Hoare triple {2576#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2577#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:58,392 INFO L273 TraceCheckUtils]: 16: Hoare triple {2577#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2578#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:58,394 INFO L273 TraceCheckUtils]: 17: Hoare triple {2578#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2579#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:58,396 INFO L273 TraceCheckUtils]: 18: Hoare triple {2579#(<= main_~i~0 12)} assume !(~i~0 < 100000); {2566#false} is VALID [2018-11-23 12:09:58,396 INFO L273 TraceCheckUtils]: 19: Hoare triple {2566#false} havoc ~x~0;~x~0 := 0; {2566#false} is VALID [2018-11-23 12:09:58,396 INFO L273 TraceCheckUtils]: 20: Hoare triple {2566#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {2566#false} is VALID [2018-11-23 12:09:58,396 INFO L256 TraceCheckUtils]: 21: Hoare triple {2566#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {2566#false} is VALID [2018-11-23 12:09:58,397 INFO L273 TraceCheckUtils]: 22: Hoare triple {2566#false} ~cond := #in~cond; {2566#false} is VALID [2018-11-23 12:09:58,397 INFO L273 TraceCheckUtils]: 23: Hoare triple {2566#false} assume 0 == ~cond; {2566#false} is VALID [2018-11-23 12:09:58,397 INFO L273 TraceCheckUtils]: 24: Hoare triple {2566#false} assume !false; {2566#false} is VALID [2018-11-23 12:09:58,398 INFO L134 CoverageAnalysis]: Checked inductivity of 78 backedges. 0 proven. 78 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:58,418 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:58,419 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [15, 15] total 16 [2018-11-23 12:09:58,419 INFO L78 Accepts]: Start accepts. Automaton has 16 states. Word has length 25 [2018-11-23 12:09:58,419 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:58,419 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 16 states. [2018-11-23 12:09:58,475 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 27 edges. 27 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:58,475 INFO L459 AbstractCegarLoop]: Interpolant automaton has 16 states [2018-11-23 12:09:58,475 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 16 interpolants. [2018-11-23 12:09:58,475 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=120, Invalid=120, Unknown=0, NotChecked=0, Total=240 [2018-11-23 12:09:58,475 INFO L87 Difference]: Start difference. First operand 30 states and 31 transitions. Second operand 16 states. [2018-11-23 12:09:58,788 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:58,789 INFO L93 Difference]: Finished difference Result 42 states and 44 transitions. [2018-11-23 12:09:58,789 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 15 states. [2018-11-23 12:09:58,789 INFO L78 Accepts]: Start accepts. Automaton has 16 states. Word has length 25 [2018-11-23 12:09:58,789 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:58,789 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 16 states. [2018-11-23 12:09:58,790 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 15 states to 15 states and 44 transitions. [2018-11-23 12:09:58,790 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 16 states. [2018-11-23 12:09:58,791 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 15 states to 15 states and 44 transitions. [2018-11-23 12:09:58,791 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 15 states and 44 transitions. [2018-11-23 12:09:58,829 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 44 edges. 44 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:58,830 INFO L225 Difference]: With dead ends: 42 [2018-11-23 12:09:58,831 INFO L226 Difference]: Without dead ends: 31 [2018-11-23 12:09:58,832 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 39 GetRequests, 25 SyntacticMatches, 0 SemanticMatches, 14 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 22 ImplicationChecksByTransitivity, 0.6s TimeCoverageRelationStatistics Valid=120, Invalid=120, Unknown=0, NotChecked=0, Total=240 [2018-11-23 12:09:58,832 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 31 states. [2018-11-23 12:09:58,867 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 31 to 31. [2018-11-23 12:09:58,868 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:58,868 INFO L82 GeneralOperation]: Start isEquivalent. First operand 31 states. Second operand 31 states. [2018-11-23 12:09:58,868 INFO L74 IsIncluded]: Start isIncluded. First operand 31 states. Second operand 31 states. [2018-11-23 12:09:58,868 INFO L87 Difference]: Start difference. First operand 31 states. Second operand 31 states. [2018-11-23 12:09:58,869 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:58,869 INFO L93 Difference]: Finished difference Result 31 states and 32 transitions. [2018-11-23 12:09:58,869 INFO L276 IsEmpty]: Start isEmpty. Operand 31 states and 32 transitions. [2018-11-23 12:09:58,869 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:58,869 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:58,870 INFO L74 IsIncluded]: Start isIncluded. First operand 31 states. Second operand 31 states. [2018-11-23 12:09:58,870 INFO L87 Difference]: Start difference. First operand 31 states. Second operand 31 states. [2018-11-23 12:09:58,870 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:58,870 INFO L93 Difference]: Finished difference Result 31 states and 32 transitions. [2018-11-23 12:09:58,870 INFO L276 IsEmpty]: Start isEmpty. Operand 31 states and 32 transitions. [2018-11-23 12:09:58,871 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:58,871 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:58,871 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:58,871 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:58,871 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 31 states. [2018-11-23 12:09:58,872 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 31 states to 31 states and 32 transitions. [2018-11-23 12:09:58,872 INFO L78 Accepts]: Start accepts. Automaton has 31 states and 32 transitions. Word has length 25 [2018-11-23 12:09:58,872 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:58,872 INFO L480 AbstractCegarLoop]: Abstraction has 31 states and 32 transitions. [2018-11-23 12:09:58,872 INFO L481 AbstractCegarLoop]: Interpolant automaton has 16 states. [2018-11-23 12:09:58,872 INFO L276 IsEmpty]: Start isEmpty. Operand 31 states and 32 transitions. [2018-11-23 12:09:58,872 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 27 [2018-11-23 12:09:58,872 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:58,873 INFO L402 BasicCegarLoop]: trace histogram [13, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:58,873 INFO L423 AbstractCegarLoop]: === Iteration 15 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:58,873 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:58,873 INFO L82 PathProgramCache]: Analyzing trace with hash 2116268398, now seen corresponding path program 13 times [2018-11-23 12:09:58,873 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:58,873 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:58,874 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:58,874 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:09:58,874 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:58,888 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:59,266 INFO L256 TraceCheckUtils]: 0: Hoare triple {2835#true} call ULTIMATE.init(); {2835#true} is VALID [2018-11-23 12:09:59,266 INFO L273 TraceCheckUtils]: 1: Hoare triple {2835#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {2835#true} is VALID [2018-11-23 12:09:59,267 INFO L273 TraceCheckUtils]: 2: Hoare triple {2835#true} assume true; {2835#true} is VALID [2018-11-23 12:09:59,267 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2835#true} {2835#true} #48#return; {2835#true} is VALID [2018-11-23 12:09:59,267 INFO L256 TraceCheckUtils]: 4: Hoare triple {2835#true} call #t~ret6 := main(); {2835#true} is VALID [2018-11-23 12:09:59,268 INFO L273 TraceCheckUtils]: 5: Hoare triple {2835#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {2837#(= main_~i~0 0)} is VALID [2018-11-23 12:09:59,269 INFO L273 TraceCheckUtils]: 6: Hoare triple {2837#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2838#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:59,270 INFO L273 TraceCheckUtils]: 7: Hoare triple {2838#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2839#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:59,270 INFO L273 TraceCheckUtils]: 8: Hoare triple {2839#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2840#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:59,271 INFO L273 TraceCheckUtils]: 9: Hoare triple {2840#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2841#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:59,272 INFO L273 TraceCheckUtils]: 10: Hoare triple {2841#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2842#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:59,272 INFO L273 TraceCheckUtils]: 11: Hoare triple {2842#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2843#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:59,273 INFO L273 TraceCheckUtils]: 12: Hoare triple {2843#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2844#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:59,275 INFO L273 TraceCheckUtils]: 13: Hoare triple {2844#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2845#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:59,276 INFO L273 TraceCheckUtils]: 14: Hoare triple {2845#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2846#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:59,277 INFO L273 TraceCheckUtils]: 15: Hoare triple {2846#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2847#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:59,278 INFO L273 TraceCheckUtils]: 16: Hoare triple {2847#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2848#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:59,279 INFO L273 TraceCheckUtils]: 17: Hoare triple {2848#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2849#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:59,282 INFO L273 TraceCheckUtils]: 18: Hoare triple {2849#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2850#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:59,282 INFO L273 TraceCheckUtils]: 19: Hoare triple {2850#(<= main_~i~0 13)} assume !(~i~0 < 100000); {2836#false} is VALID [2018-11-23 12:09:59,283 INFO L273 TraceCheckUtils]: 20: Hoare triple {2836#false} havoc ~x~0;~x~0 := 0; {2836#false} is VALID [2018-11-23 12:09:59,283 INFO L273 TraceCheckUtils]: 21: Hoare triple {2836#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {2836#false} is VALID [2018-11-23 12:09:59,283 INFO L256 TraceCheckUtils]: 22: Hoare triple {2836#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {2836#false} is VALID [2018-11-23 12:09:59,283 INFO L273 TraceCheckUtils]: 23: Hoare triple {2836#false} ~cond := #in~cond; {2836#false} is VALID [2018-11-23 12:09:59,283 INFO L273 TraceCheckUtils]: 24: Hoare triple {2836#false} assume 0 == ~cond; {2836#false} is VALID [2018-11-23 12:09:59,283 INFO L273 TraceCheckUtils]: 25: Hoare triple {2836#false} assume !false; {2836#false} is VALID [2018-11-23 12:09:59,284 INFO L134 CoverageAnalysis]: Checked inductivity of 91 backedges. 0 proven. 91 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:59,284 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:09:59,285 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:59,299 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:59,329 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:59,338 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:09:59,339 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:09:59,496 INFO L256 TraceCheckUtils]: 0: Hoare triple {2835#true} call ULTIMATE.init(); {2835#true} is VALID [2018-11-23 12:09:59,496 INFO L273 TraceCheckUtils]: 1: Hoare triple {2835#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {2835#true} is VALID [2018-11-23 12:09:59,496 INFO L273 TraceCheckUtils]: 2: Hoare triple {2835#true} assume true; {2835#true} is VALID [2018-11-23 12:09:59,496 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {2835#true} {2835#true} #48#return; {2835#true} is VALID [2018-11-23 12:09:59,496 INFO L256 TraceCheckUtils]: 4: Hoare triple {2835#true} call #t~ret6 := main(); {2835#true} is VALID [2018-11-23 12:09:59,497 INFO L273 TraceCheckUtils]: 5: Hoare triple {2835#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {2869#(<= main_~i~0 0)} is VALID [2018-11-23 12:09:59,498 INFO L273 TraceCheckUtils]: 6: Hoare triple {2869#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2838#(<= main_~i~0 1)} is VALID [2018-11-23 12:09:59,498 INFO L273 TraceCheckUtils]: 7: Hoare triple {2838#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2839#(<= main_~i~0 2)} is VALID [2018-11-23 12:09:59,499 INFO L273 TraceCheckUtils]: 8: Hoare triple {2839#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2840#(<= main_~i~0 3)} is VALID [2018-11-23 12:09:59,500 INFO L273 TraceCheckUtils]: 9: Hoare triple {2840#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2841#(<= main_~i~0 4)} is VALID [2018-11-23 12:09:59,500 INFO L273 TraceCheckUtils]: 10: Hoare triple {2841#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2842#(<= main_~i~0 5)} is VALID [2018-11-23 12:09:59,501 INFO L273 TraceCheckUtils]: 11: Hoare triple {2842#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2843#(<= main_~i~0 6)} is VALID [2018-11-23 12:09:59,502 INFO L273 TraceCheckUtils]: 12: Hoare triple {2843#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2844#(<= main_~i~0 7)} is VALID [2018-11-23 12:09:59,503 INFO L273 TraceCheckUtils]: 13: Hoare triple {2844#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2845#(<= main_~i~0 8)} is VALID [2018-11-23 12:09:59,504 INFO L273 TraceCheckUtils]: 14: Hoare triple {2845#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2846#(<= main_~i~0 9)} is VALID [2018-11-23 12:09:59,506 INFO L273 TraceCheckUtils]: 15: Hoare triple {2846#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2847#(<= main_~i~0 10)} is VALID [2018-11-23 12:09:59,507 INFO L273 TraceCheckUtils]: 16: Hoare triple {2847#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2848#(<= main_~i~0 11)} is VALID [2018-11-23 12:09:59,508 INFO L273 TraceCheckUtils]: 17: Hoare triple {2848#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2849#(<= main_~i~0 12)} is VALID [2018-11-23 12:09:59,509 INFO L273 TraceCheckUtils]: 18: Hoare triple {2849#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {2850#(<= main_~i~0 13)} is VALID [2018-11-23 12:09:59,510 INFO L273 TraceCheckUtils]: 19: Hoare triple {2850#(<= main_~i~0 13)} assume !(~i~0 < 100000); {2836#false} is VALID [2018-11-23 12:09:59,510 INFO L273 TraceCheckUtils]: 20: Hoare triple {2836#false} havoc ~x~0;~x~0 := 0; {2836#false} is VALID [2018-11-23 12:09:59,510 INFO L273 TraceCheckUtils]: 21: Hoare triple {2836#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {2836#false} is VALID [2018-11-23 12:09:59,510 INFO L256 TraceCheckUtils]: 22: Hoare triple {2836#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {2836#false} is VALID [2018-11-23 12:09:59,511 INFO L273 TraceCheckUtils]: 23: Hoare triple {2836#false} ~cond := #in~cond; {2836#false} is VALID [2018-11-23 12:09:59,511 INFO L273 TraceCheckUtils]: 24: Hoare triple {2836#false} assume 0 == ~cond; {2836#false} is VALID [2018-11-23 12:09:59,511 INFO L273 TraceCheckUtils]: 25: Hoare triple {2836#false} assume !false; {2836#false} is VALID [2018-11-23 12:09:59,512 INFO L134 CoverageAnalysis]: Checked inductivity of 91 backedges. 0 proven. 91 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:09:59,531 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:09:59,532 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [16, 16] total 17 [2018-11-23 12:09:59,532 INFO L78 Accepts]: Start accepts. Automaton has 17 states. Word has length 26 [2018-11-23 12:09:59,532 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:09:59,532 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 17 states. [2018-11-23 12:09:59,555 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 28 edges. 28 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:59,556 INFO L459 AbstractCegarLoop]: Interpolant automaton has 17 states [2018-11-23 12:09:59,556 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 17 interpolants. [2018-11-23 12:09:59,557 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=136, Invalid=136, Unknown=0, NotChecked=0, Total=272 [2018-11-23 12:09:59,557 INFO L87 Difference]: Start difference. First operand 31 states and 32 transitions. Second operand 17 states. [2018-11-23 12:09:59,687 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:59,687 INFO L93 Difference]: Finished difference Result 43 states and 45 transitions. [2018-11-23 12:09:59,687 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 16 states. [2018-11-23 12:09:59,688 INFO L78 Accepts]: Start accepts. Automaton has 17 states. Word has length 26 [2018-11-23 12:09:59,688 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:09:59,688 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 17 states. [2018-11-23 12:09:59,689 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 16 states to 16 states and 45 transitions. [2018-11-23 12:09:59,689 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 17 states. [2018-11-23 12:09:59,692 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 16 states to 16 states and 45 transitions. [2018-11-23 12:09:59,692 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 16 states and 45 transitions. [2018-11-23 12:09:59,738 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 45 edges. 45 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:09:59,739 INFO L225 Difference]: With dead ends: 43 [2018-11-23 12:09:59,739 INFO L226 Difference]: Without dead ends: 32 [2018-11-23 12:09:59,740 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 41 GetRequests, 26 SyntacticMatches, 0 SemanticMatches, 15 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 24 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=136, Invalid=136, Unknown=0, NotChecked=0, Total=272 [2018-11-23 12:09:59,741 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 32 states. [2018-11-23 12:09:59,779 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 32 to 32. [2018-11-23 12:09:59,779 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:09:59,780 INFO L82 GeneralOperation]: Start isEquivalent. First operand 32 states. Second operand 32 states. [2018-11-23 12:09:59,780 INFO L74 IsIncluded]: Start isIncluded. First operand 32 states. Second operand 32 states. [2018-11-23 12:09:59,780 INFO L87 Difference]: Start difference. First operand 32 states. Second operand 32 states. [2018-11-23 12:09:59,781 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:59,781 INFO L93 Difference]: Finished difference Result 32 states and 33 transitions. [2018-11-23 12:09:59,781 INFO L276 IsEmpty]: Start isEmpty. Operand 32 states and 33 transitions. [2018-11-23 12:09:59,781 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:59,781 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:59,781 INFO L74 IsIncluded]: Start isIncluded. First operand 32 states. Second operand 32 states. [2018-11-23 12:09:59,782 INFO L87 Difference]: Start difference. First operand 32 states. Second operand 32 states. [2018-11-23 12:09:59,782 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:09:59,783 INFO L93 Difference]: Finished difference Result 32 states and 33 transitions. [2018-11-23 12:09:59,783 INFO L276 IsEmpty]: Start isEmpty. Operand 32 states and 33 transitions. [2018-11-23 12:09:59,783 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:09:59,783 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:09:59,784 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:09:59,784 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:09:59,784 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 32 states. [2018-11-23 12:09:59,785 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 32 states to 32 states and 33 transitions. [2018-11-23 12:09:59,785 INFO L78 Accepts]: Start accepts. Automaton has 32 states and 33 transitions. Word has length 26 [2018-11-23 12:09:59,785 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:09:59,785 INFO L480 AbstractCegarLoop]: Abstraction has 32 states and 33 transitions. [2018-11-23 12:09:59,785 INFO L481 AbstractCegarLoop]: Interpolant automaton has 17 states. [2018-11-23 12:09:59,786 INFO L276 IsEmpty]: Start isEmpty. Operand 32 states and 33 transitions. [2018-11-23 12:09:59,786 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 28 [2018-11-23 12:09:59,786 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:09:59,786 INFO L402 BasicCegarLoop]: trace histogram [14, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:09:59,787 INFO L423 AbstractCegarLoop]: === Iteration 16 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:09:59,787 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:09:59,787 INFO L82 PathProgramCache]: Analyzing trace with hash -911267790, now seen corresponding path program 14 times [2018-11-23 12:09:59,787 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:09:59,787 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:09:59,788 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:59,788 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:09:59,788 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:09:59,804 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:00,105 INFO L256 TraceCheckUtils]: 0: Hoare triple {3115#true} call ULTIMATE.init(); {3115#true} is VALID [2018-11-23 12:10:00,105 INFO L273 TraceCheckUtils]: 1: Hoare triple {3115#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {3115#true} is VALID [2018-11-23 12:10:00,105 INFO L273 TraceCheckUtils]: 2: Hoare triple {3115#true} assume true; {3115#true} is VALID [2018-11-23 12:10:00,106 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3115#true} {3115#true} #48#return; {3115#true} is VALID [2018-11-23 12:10:00,106 INFO L256 TraceCheckUtils]: 4: Hoare triple {3115#true} call #t~ret6 := main(); {3115#true} is VALID [2018-11-23 12:10:00,107 INFO L273 TraceCheckUtils]: 5: Hoare triple {3115#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {3117#(= main_~i~0 0)} is VALID [2018-11-23 12:10:00,108 INFO L273 TraceCheckUtils]: 6: Hoare triple {3117#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3118#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:00,108 INFO L273 TraceCheckUtils]: 7: Hoare triple {3118#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3119#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:00,109 INFO L273 TraceCheckUtils]: 8: Hoare triple {3119#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3120#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:00,110 INFO L273 TraceCheckUtils]: 9: Hoare triple {3120#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3121#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:00,111 INFO L273 TraceCheckUtils]: 10: Hoare triple {3121#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3122#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:00,113 INFO L273 TraceCheckUtils]: 11: Hoare triple {3122#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3123#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:00,114 INFO L273 TraceCheckUtils]: 12: Hoare triple {3123#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3124#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:00,115 INFO L273 TraceCheckUtils]: 13: Hoare triple {3124#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3125#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:00,116 INFO L273 TraceCheckUtils]: 14: Hoare triple {3125#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3126#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:00,118 INFO L273 TraceCheckUtils]: 15: Hoare triple {3126#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3127#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:00,119 INFO L273 TraceCheckUtils]: 16: Hoare triple {3127#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3128#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:00,120 INFO L273 TraceCheckUtils]: 17: Hoare triple {3128#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3129#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:00,122 INFO L273 TraceCheckUtils]: 18: Hoare triple {3129#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3130#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:00,123 INFO L273 TraceCheckUtils]: 19: Hoare triple {3130#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3131#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:00,124 INFO L273 TraceCheckUtils]: 20: Hoare triple {3131#(<= main_~i~0 14)} assume !(~i~0 < 100000); {3116#false} is VALID [2018-11-23 12:10:00,124 INFO L273 TraceCheckUtils]: 21: Hoare triple {3116#false} havoc ~x~0;~x~0 := 0; {3116#false} is VALID [2018-11-23 12:10:00,124 INFO L273 TraceCheckUtils]: 22: Hoare triple {3116#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {3116#false} is VALID [2018-11-23 12:10:00,125 INFO L256 TraceCheckUtils]: 23: Hoare triple {3116#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {3116#false} is VALID [2018-11-23 12:10:00,125 INFO L273 TraceCheckUtils]: 24: Hoare triple {3116#false} ~cond := #in~cond; {3116#false} is VALID [2018-11-23 12:10:00,125 INFO L273 TraceCheckUtils]: 25: Hoare triple {3116#false} assume 0 == ~cond; {3116#false} is VALID [2018-11-23 12:10:00,126 INFO L273 TraceCheckUtils]: 26: Hoare triple {3116#false} assume !false; {3116#false} is VALID [2018-11-23 12:10:00,127 INFO L134 CoverageAnalysis]: Checked inductivity of 105 backedges. 0 proven. 105 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:00,128 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:00,128 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:10:00,138 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:10:00,188 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:10:00,188 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:00,223 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:00,224 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:00,410 INFO L256 TraceCheckUtils]: 0: Hoare triple {3115#true} call ULTIMATE.init(); {3115#true} is VALID [2018-11-23 12:10:00,411 INFO L273 TraceCheckUtils]: 1: Hoare triple {3115#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {3115#true} is VALID [2018-11-23 12:10:00,411 INFO L273 TraceCheckUtils]: 2: Hoare triple {3115#true} assume true; {3115#true} is VALID [2018-11-23 12:10:00,411 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3115#true} {3115#true} #48#return; {3115#true} is VALID [2018-11-23 12:10:00,412 INFO L256 TraceCheckUtils]: 4: Hoare triple {3115#true} call #t~ret6 := main(); {3115#true} is VALID [2018-11-23 12:10:00,413 INFO L273 TraceCheckUtils]: 5: Hoare triple {3115#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {3150#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:00,414 INFO L273 TraceCheckUtils]: 6: Hoare triple {3150#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3118#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:00,415 INFO L273 TraceCheckUtils]: 7: Hoare triple {3118#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3119#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:00,415 INFO L273 TraceCheckUtils]: 8: Hoare triple {3119#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3120#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:00,416 INFO L273 TraceCheckUtils]: 9: Hoare triple {3120#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3121#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:00,417 INFO L273 TraceCheckUtils]: 10: Hoare triple {3121#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3122#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:00,419 INFO L273 TraceCheckUtils]: 11: Hoare triple {3122#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3123#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:00,420 INFO L273 TraceCheckUtils]: 12: Hoare triple {3123#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3124#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:00,421 INFO L273 TraceCheckUtils]: 13: Hoare triple {3124#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3125#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:00,422 INFO L273 TraceCheckUtils]: 14: Hoare triple {3125#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3126#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:00,424 INFO L273 TraceCheckUtils]: 15: Hoare triple {3126#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3127#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:00,425 INFO L273 TraceCheckUtils]: 16: Hoare triple {3127#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3128#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:00,426 INFO L273 TraceCheckUtils]: 17: Hoare triple {3128#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3129#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:00,427 INFO L273 TraceCheckUtils]: 18: Hoare triple {3129#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3130#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:00,429 INFO L273 TraceCheckUtils]: 19: Hoare triple {3130#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3131#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:00,429 INFO L273 TraceCheckUtils]: 20: Hoare triple {3131#(<= main_~i~0 14)} assume !(~i~0 < 100000); {3116#false} is VALID [2018-11-23 12:10:00,430 INFO L273 TraceCheckUtils]: 21: Hoare triple {3116#false} havoc ~x~0;~x~0 := 0; {3116#false} is VALID [2018-11-23 12:10:00,430 INFO L273 TraceCheckUtils]: 22: Hoare triple {3116#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {3116#false} is VALID [2018-11-23 12:10:00,430 INFO L256 TraceCheckUtils]: 23: Hoare triple {3116#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {3116#false} is VALID [2018-11-23 12:10:00,431 INFO L273 TraceCheckUtils]: 24: Hoare triple {3116#false} ~cond := #in~cond; {3116#false} is VALID [2018-11-23 12:10:00,431 INFO L273 TraceCheckUtils]: 25: Hoare triple {3116#false} assume 0 == ~cond; {3116#false} is VALID [2018-11-23 12:10:00,431 INFO L273 TraceCheckUtils]: 26: Hoare triple {3116#false} assume !false; {3116#false} is VALID [2018-11-23 12:10:00,432 INFO L134 CoverageAnalysis]: Checked inductivity of 105 backedges. 0 proven. 105 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:00,452 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:00,452 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [17, 17] total 18 [2018-11-23 12:10:00,453 INFO L78 Accepts]: Start accepts. Automaton has 18 states. Word has length 27 [2018-11-23 12:10:00,453 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:00,453 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 18 states. [2018-11-23 12:10:00,479 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:10:00,479 INFO L459 AbstractCegarLoop]: Interpolant automaton has 18 states [2018-11-23 12:10:00,479 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 18 interpolants. [2018-11-23 12:10:00,480 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=153, Invalid=153, Unknown=0, NotChecked=0, Total=306 [2018-11-23 12:10:00,480 INFO L87 Difference]: Start difference. First operand 32 states and 33 transitions. Second operand 18 states. [2018-11-23 12:10:00,787 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:00,788 INFO L93 Difference]: Finished difference Result 44 states and 46 transitions. [2018-11-23 12:10:00,788 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 17 states. [2018-11-23 12:10:00,788 INFO L78 Accepts]: Start accepts. Automaton has 18 states. Word has length 27 [2018-11-23 12:10:00,788 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:00,788 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 18 states. [2018-11-23 12:10:00,789 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 17 states to 17 states and 46 transitions. [2018-11-23 12:10:00,789 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 18 states. [2018-11-23 12:10:00,790 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 17 states to 17 states and 46 transitions. [2018-11-23 12:10:00,790 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 17 states and 46 transitions. [2018-11-23 12:10:00,860 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 46 edges. 46 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:00,861 INFO L225 Difference]: With dead ends: 44 [2018-11-23 12:10:00,861 INFO L226 Difference]: Without dead ends: 33 [2018-11-23 12:10:00,861 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 43 GetRequests, 27 SyntacticMatches, 0 SemanticMatches, 16 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 26 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=153, Invalid=153, Unknown=0, NotChecked=0, Total=306 [2018-11-23 12:10:00,862 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 33 states. [2018-11-23 12:10:00,889 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 33 to 33. [2018-11-23 12:10:00,889 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:00,889 INFO L82 GeneralOperation]: Start isEquivalent. First operand 33 states. Second operand 33 states. [2018-11-23 12:10:00,889 INFO L74 IsIncluded]: Start isIncluded. First operand 33 states. Second operand 33 states. [2018-11-23 12:10:00,889 INFO L87 Difference]: Start difference. First operand 33 states. Second operand 33 states. [2018-11-23 12:10:00,891 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:00,891 INFO L93 Difference]: Finished difference Result 33 states and 34 transitions. [2018-11-23 12:10:00,891 INFO L276 IsEmpty]: Start isEmpty. Operand 33 states and 34 transitions. [2018-11-23 12:10:00,891 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:00,891 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:00,891 INFO L74 IsIncluded]: Start isIncluded. First operand 33 states. Second operand 33 states. [2018-11-23 12:10:00,892 INFO L87 Difference]: Start difference. First operand 33 states. Second operand 33 states. [2018-11-23 12:10:00,892 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:00,892 INFO L93 Difference]: Finished difference Result 33 states and 34 transitions. [2018-11-23 12:10:00,893 INFO L276 IsEmpty]: Start isEmpty. Operand 33 states and 34 transitions. [2018-11-23 12:10:00,893 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:00,893 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:00,893 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:00,893 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:00,893 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 33 states. [2018-11-23 12:10:00,894 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 33 states to 33 states and 34 transitions. [2018-11-23 12:10:00,894 INFO L78 Accepts]: Start accepts. Automaton has 33 states and 34 transitions. Word has length 27 [2018-11-23 12:10:00,895 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:00,895 INFO L480 AbstractCegarLoop]: Abstraction has 33 states and 34 transitions. [2018-11-23 12:10:00,895 INFO L481 AbstractCegarLoop]: Interpolant automaton has 18 states. [2018-11-23 12:10:00,895 INFO L276 IsEmpty]: Start isEmpty. Operand 33 states and 34 transitions. [2018-11-23 12:10:00,895 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 29 [2018-11-23 12:10:00,895 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:00,895 INFO L402 BasicCegarLoop]: trace histogram [15, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:00,896 INFO L423 AbstractCegarLoop]: === Iteration 17 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:00,896 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:00,896 INFO L82 PathProgramCache]: Analyzing trace with hash -275609106, now seen corresponding path program 15 times [2018-11-23 12:10:00,896 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:00,896 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:00,897 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:00,897 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:00,897 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:00,913 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:01,581 INFO L256 TraceCheckUtils]: 0: Hoare triple {3405#true} call ULTIMATE.init(); {3405#true} is VALID [2018-11-23 12:10:01,581 INFO L273 TraceCheckUtils]: 1: Hoare triple {3405#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {3405#true} is VALID [2018-11-23 12:10:01,581 INFO L273 TraceCheckUtils]: 2: Hoare triple {3405#true} assume true; {3405#true} is VALID [2018-11-23 12:10:01,582 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3405#true} {3405#true} #48#return; {3405#true} is VALID [2018-11-23 12:10:01,582 INFO L256 TraceCheckUtils]: 4: Hoare triple {3405#true} call #t~ret6 := main(); {3405#true} is VALID [2018-11-23 12:10:01,583 INFO L273 TraceCheckUtils]: 5: Hoare triple {3405#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {3407#(= main_~i~0 0)} is VALID [2018-11-23 12:10:01,584 INFO L273 TraceCheckUtils]: 6: Hoare triple {3407#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3408#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:01,585 INFO L273 TraceCheckUtils]: 7: Hoare triple {3408#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3409#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:01,586 INFO L273 TraceCheckUtils]: 8: Hoare triple {3409#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3410#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:01,587 INFO L273 TraceCheckUtils]: 9: Hoare triple {3410#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3411#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:01,588 INFO L273 TraceCheckUtils]: 10: Hoare triple {3411#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3412#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:01,590 INFO L273 TraceCheckUtils]: 11: Hoare triple {3412#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3413#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:01,591 INFO L273 TraceCheckUtils]: 12: Hoare triple {3413#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3414#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:01,592 INFO L273 TraceCheckUtils]: 13: Hoare triple {3414#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3415#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:01,593 INFO L273 TraceCheckUtils]: 14: Hoare triple {3415#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3416#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:01,594 INFO L273 TraceCheckUtils]: 15: Hoare triple {3416#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3417#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:01,614 INFO L273 TraceCheckUtils]: 16: Hoare triple {3417#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3418#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:01,628 INFO L273 TraceCheckUtils]: 17: Hoare triple {3418#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3419#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:01,645 INFO L273 TraceCheckUtils]: 18: Hoare triple {3419#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3420#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:01,659 INFO L273 TraceCheckUtils]: 19: Hoare triple {3420#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3421#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:01,674 INFO L273 TraceCheckUtils]: 20: Hoare triple {3421#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3422#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:01,683 INFO L273 TraceCheckUtils]: 21: Hoare triple {3422#(<= main_~i~0 15)} assume !(~i~0 < 100000); {3406#false} is VALID [2018-11-23 12:10:01,683 INFO L273 TraceCheckUtils]: 22: Hoare triple {3406#false} havoc ~x~0;~x~0 := 0; {3406#false} is VALID [2018-11-23 12:10:01,684 INFO L273 TraceCheckUtils]: 23: Hoare triple {3406#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {3406#false} is VALID [2018-11-23 12:10:01,684 INFO L256 TraceCheckUtils]: 24: Hoare triple {3406#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {3406#false} is VALID [2018-11-23 12:10:01,684 INFO L273 TraceCheckUtils]: 25: Hoare triple {3406#false} ~cond := #in~cond; {3406#false} is VALID [2018-11-23 12:10:01,684 INFO L273 TraceCheckUtils]: 26: Hoare triple {3406#false} assume 0 == ~cond; {3406#false} is VALID [2018-11-23 12:10:01,684 INFO L273 TraceCheckUtils]: 27: Hoare triple {3406#false} assume !false; {3406#false} is VALID [2018-11-23 12:10:01,685 INFO L134 CoverageAnalysis]: Checked inductivity of 120 backedges. 0 proven. 120 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:01,685 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:01,686 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:10:01,701 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:10:02,149 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 9 check-sat command(s) [2018-11-23 12:10:02,150 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:02,162 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:02,163 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:02,293 INFO L256 TraceCheckUtils]: 0: Hoare triple {3405#true} call ULTIMATE.init(); {3405#true} is VALID [2018-11-23 12:10:02,293 INFO L273 TraceCheckUtils]: 1: Hoare triple {3405#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {3405#true} is VALID [2018-11-23 12:10:02,293 INFO L273 TraceCheckUtils]: 2: Hoare triple {3405#true} assume true; {3405#true} is VALID [2018-11-23 12:10:02,293 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3405#true} {3405#true} #48#return; {3405#true} is VALID [2018-11-23 12:10:02,294 INFO L256 TraceCheckUtils]: 4: Hoare triple {3405#true} call #t~ret6 := main(); {3405#true} is VALID [2018-11-23 12:10:02,295 INFO L273 TraceCheckUtils]: 5: Hoare triple {3405#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {3441#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:02,296 INFO L273 TraceCheckUtils]: 6: Hoare triple {3441#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3408#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:02,296 INFO L273 TraceCheckUtils]: 7: Hoare triple {3408#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3409#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:02,297 INFO L273 TraceCheckUtils]: 8: Hoare triple {3409#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3410#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:02,298 INFO L273 TraceCheckUtils]: 9: Hoare triple {3410#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3411#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:02,299 INFO L273 TraceCheckUtils]: 10: Hoare triple {3411#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3412#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:02,300 INFO L273 TraceCheckUtils]: 11: Hoare triple {3412#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3413#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:02,301 INFO L273 TraceCheckUtils]: 12: Hoare triple {3413#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3414#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:02,303 INFO L273 TraceCheckUtils]: 13: Hoare triple {3414#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3415#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:02,304 INFO L273 TraceCheckUtils]: 14: Hoare triple {3415#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3416#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:02,305 INFO L273 TraceCheckUtils]: 15: Hoare triple {3416#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3417#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:02,306 INFO L273 TraceCheckUtils]: 16: Hoare triple {3417#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3418#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:02,307 INFO L273 TraceCheckUtils]: 17: Hoare triple {3418#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3419#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:02,308 INFO L273 TraceCheckUtils]: 18: Hoare triple {3419#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3420#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:02,309 INFO L273 TraceCheckUtils]: 19: Hoare triple {3420#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3421#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:02,310 INFO L273 TraceCheckUtils]: 20: Hoare triple {3421#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3422#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:02,311 INFO L273 TraceCheckUtils]: 21: Hoare triple {3422#(<= main_~i~0 15)} assume !(~i~0 < 100000); {3406#false} is VALID [2018-11-23 12:10:02,311 INFO L273 TraceCheckUtils]: 22: Hoare triple {3406#false} havoc ~x~0;~x~0 := 0; {3406#false} is VALID [2018-11-23 12:10:02,311 INFO L273 TraceCheckUtils]: 23: Hoare triple {3406#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {3406#false} is VALID [2018-11-23 12:10:02,312 INFO L256 TraceCheckUtils]: 24: Hoare triple {3406#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {3406#false} is VALID [2018-11-23 12:10:02,312 INFO L273 TraceCheckUtils]: 25: Hoare triple {3406#false} ~cond := #in~cond; {3406#false} is VALID [2018-11-23 12:10:02,312 INFO L273 TraceCheckUtils]: 26: Hoare triple {3406#false} assume 0 == ~cond; {3406#false} is VALID [2018-11-23 12:10:02,312 INFO L273 TraceCheckUtils]: 27: Hoare triple {3406#false} assume !false; {3406#false} is VALID [2018-11-23 12:10:02,313 INFO L134 CoverageAnalysis]: Checked inductivity of 120 backedges. 0 proven. 120 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:02,333 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:02,333 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [18, 18] total 19 [2018-11-23 12:10:02,333 INFO L78 Accepts]: Start accepts. Automaton has 19 states. Word has length 28 [2018-11-23 12:10:02,334 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:02,334 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 19 states. [2018-11-23 12:10:02,360 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:10:02,360 INFO L459 AbstractCegarLoop]: Interpolant automaton has 19 states [2018-11-23 12:10:02,360 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 19 interpolants. [2018-11-23 12:10:02,361 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=171, Invalid=171, Unknown=0, NotChecked=0, Total=342 [2018-11-23 12:10:02,361 INFO L87 Difference]: Start difference. First operand 33 states and 34 transitions. Second operand 19 states. [2018-11-23 12:10:02,657 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:02,658 INFO L93 Difference]: Finished difference Result 45 states and 47 transitions. [2018-11-23 12:10:02,658 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 18 states. [2018-11-23 12:10:02,658 INFO L78 Accepts]: Start accepts. Automaton has 19 states. Word has length 28 [2018-11-23 12:10:02,658 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:02,659 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 19 states. [2018-11-23 12:10:02,660 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 18 states to 18 states and 47 transitions. [2018-11-23 12:10:02,660 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 19 states. [2018-11-23 12:10:02,661 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 18 states to 18 states and 47 transitions. [2018-11-23 12:10:02,661 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 18 states and 47 transitions. [2018-11-23 12:10:02,700 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:10:02,701 INFO L225 Difference]: With dead ends: 45 [2018-11-23 12:10:02,701 INFO L226 Difference]: Without dead ends: 34 [2018-11-23 12:10:02,702 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 45 GetRequests, 28 SyntacticMatches, 0 SemanticMatches, 17 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 28 ImplicationChecksByTransitivity, 0.5s TimeCoverageRelationStatistics Valid=171, Invalid=171, Unknown=0, NotChecked=0, Total=342 [2018-11-23 12:10:02,702 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 34 states. [2018-11-23 12:10:02,718 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 34 to 34. [2018-11-23 12:10:02,718 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:02,719 INFO L82 GeneralOperation]: Start isEquivalent. First operand 34 states. Second operand 34 states. [2018-11-23 12:10:02,719 INFO L74 IsIncluded]: Start isIncluded. First operand 34 states. Second operand 34 states. [2018-11-23 12:10:02,719 INFO L87 Difference]: Start difference. First operand 34 states. Second operand 34 states. [2018-11-23 12:10:02,720 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:02,720 INFO L93 Difference]: Finished difference Result 34 states and 35 transitions. [2018-11-23 12:10:02,720 INFO L276 IsEmpty]: Start isEmpty. Operand 34 states and 35 transitions. [2018-11-23 12:10:02,720 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:02,720 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:02,721 INFO L74 IsIncluded]: Start isIncluded. First operand 34 states. Second operand 34 states. [2018-11-23 12:10:02,721 INFO L87 Difference]: Start difference. First operand 34 states. Second operand 34 states. [2018-11-23 12:10:02,721 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:02,721 INFO L93 Difference]: Finished difference Result 34 states and 35 transitions. [2018-11-23 12:10:02,721 INFO L276 IsEmpty]: Start isEmpty. Operand 34 states and 35 transitions. [2018-11-23 12:10:02,722 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:02,722 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:02,722 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:02,722 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:02,722 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 34 states. [2018-11-23 12:10:02,723 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 34 states to 34 states and 35 transitions. [2018-11-23 12:10:02,723 INFO L78 Accepts]: Start accepts. Automaton has 34 states and 35 transitions. Word has length 28 [2018-11-23 12:10:02,723 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:02,723 INFO L480 AbstractCegarLoop]: Abstraction has 34 states and 35 transitions. [2018-11-23 12:10:02,723 INFO L481 AbstractCegarLoop]: Interpolant automaton has 19 states. [2018-11-23 12:10:02,723 INFO L276 IsEmpty]: Start isEmpty. Operand 34 states and 35 transitions. [2018-11-23 12:10:02,724 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 30 [2018-11-23 12:10:02,724 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:02,724 INFO L402 BasicCegarLoop]: trace histogram [16, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:02,724 INFO L423 AbstractCegarLoop]: === Iteration 18 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:02,724 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:02,724 INFO L82 PathProgramCache]: Analyzing trace with hash -2045026382, now seen corresponding path program 16 times [2018-11-23 12:10:02,724 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:02,725 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:02,725 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:02,725 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:02,726 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:02,741 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:03,269 INFO L256 TraceCheckUtils]: 0: Hoare triple {3705#true} call ULTIMATE.init(); {3705#true} is VALID [2018-11-23 12:10:03,269 INFO L273 TraceCheckUtils]: 1: Hoare triple {3705#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {3705#true} is VALID [2018-11-23 12:10:03,269 INFO L273 TraceCheckUtils]: 2: Hoare triple {3705#true} assume true; {3705#true} is VALID [2018-11-23 12:10:03,269 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3705#true} {3705#true} #48#return; {3705#true} is VALID [2018-11-23 12:10:03,270 INFO L256 TraceCheckUtils]: 4: Hoare triple {3705#true} call #t~ret6 := main(); {3705#true} is VALID [2018-11-23 12:10:03,288 INFO L273 TraceCheckUtils]: 5: Hoare triple {3705#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {3707#(= main_~i~0 0)} is VALID [2018-11-23 12:10:03,292 INFO L273 TraceCheckUtils]: 6: Hoare triple {3707#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3708#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:03,293 INFO L273 TraceCheckUtils]: 7: Hoare triple {3708#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3709#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:03,293 INFO L273 TraceCheckUtils]: 8: Hoare triple {3709#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3710#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:03,296 INFO L273 TraceCheckUtils]: 9: Hoare triple {3710#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3711#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:03,296 INFO L273 TraceCheckUtils]: 10: Hoare triple {3711#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3712#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:03,298 INFO L273 TraceCheckUtils]: 11: Hoare triple {3712#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3713#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:03,298 INFO L273 TraceCheckUtils]: 12: Hoare triple {3713#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3714#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:03,300 INFO L273 TraceCheckUtils]: 13: Hoare triple {3714#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3715#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:03,301 INFO L273 TraceCheckUtils]: 14: Hoare triple {3715#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3716#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:03,302 INFO L273 TraceCheckUtils]: 15: Hoare triple {3716#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3717#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:03,303 INFO L273 TraceCheckUtils]: 16: Hoare triple {3717#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3718#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:03,305 INFO L273 TraceCheckUtils]: 17: Hoare triple {3718#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3719#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:03,306 INFO L273 TraceCheckUtils]: 18: Hoare triple {3719#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3720#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:03,312 INFO L273 TraceCheckUtils]: 19: Hoare triple {3720#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3721#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:03,313 INFO L273 TraceCheckUtils]: 20: Hoare triple {3721#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3722#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:03,313 INFO L273 TraceCheckUtils]: 21: Hoare triple {3722#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3723#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:03,314 INFO L273 TraceCheckUtils]: 22: Hoare triple {3723#(<= main_~i~0 16)} assume !(~i~0 < 100000); {3706#false} is VALID [2018-11-23 12:10:03,314 INFO L273 TraceCheckUtils]: 23: Hoare triple {3706#false} havoc ~x~0;~x~0 := 0; {3706#false} is VALID [2018-11-23 12:10:03,314 INFO L273 TraceCheckUtils]: 24: Hoare triple {3706#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {3706#false} is VALID [2018-11-23 12:10:03,314 INFO L256 TraceCheckUtils]: 25: Hoare triple {3706#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {3706#false} is VALID [2018-11-23 12:10:03,314 INFO L273 TraceCheckUtils]: 26: Hoare triple {3706#false} ~cond := #in~cond; {3706#false} is VALID [2018-11-23 12:10:03,314 INFO L273 TraceCheckUtils]: 27: Hoare triple {3706#false} assume 0 == ~cond; {3706#false} is VALID [2018-11-23 12:10:03,314 INFO L273 TraceCheckUtils]: 28: Hoare triple {3706#false} assume !false; {3706#false} is VALID [2018-11-23 12:10:03,315 INFO L134 CoverageAnalysis]: Checked inductivity of 136 backedges. 0 proven. 136 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:03,315 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:03,315 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 17 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 17 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:03,325 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:10:03,360 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:10:03,360 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:03,386 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:03,387 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:03,710 INFO L256 TraceCheckUtils]: 0: Hoare triple {3705#true} call ULTIMATE.init(); {3705#true} is VALID [2018-11-23 12:10:03,710 INFO L273 TraceCheckUtils]: 1: Hoare triple {3705#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {3705#true} is VALID [2018-11-23 12:10:03,711 INFO L273 TraceCheckUtils]: 2: Hoare triple {3705#true} assume true; {3705#true} is VALID [2018-11-23 12:10:03,711 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {3705#true} {3705#true} #48#return; {3705#true} is VALID [2018-11-23 12:10:03,711 INFO L256 TraceCheckUtils]: 4: Hoare triple {3705#true} call #t~ret6 := main(); {3705#true} is VALID [2018-11-23 12:10:03,711 INFO L273 TraceCheckUtils]: 5: Hoare triple {3705#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {3742#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:03,712 INFO L273 TraceCheckUtils]: 6: Hoare triple {3742#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3708#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:03,713 INFO L273 TraceCheckUtils]: 7: Hoare triple {3708#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3709#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:03,714 INFO L273 TraceCheckUtils]: 8: Hoare triple {3709#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3710#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:03,714 INFO L273 TraceCheckUtils]: 9: Hoare triple {3710#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3711#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:03,715 INFO L273 TraceCheckUtils]: 10: Hoare triple {3711#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3712#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:03,716 INFO L273 TraceCheckUtils]: 11: Hoare triple {3712#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3713#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:03,717 INFO L273 TraceCheckUtils]: 12: Hoare triple {3713#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3714#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:03,718 INFO L273 TraceCheckUtils]: 13: Hoare triple {3714#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3715#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:03,719 INFO L273 TraceCheckUtils]: 14: Hoare triple {3715#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3716#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:03,721 INFO L273 TraceCheckUtils]: 15: Hoare triple {3716#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3717#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:03,722 INFO L273 TraceCheckUtils]: 16: Hoare triple {3717#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3718#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:03,723 INFO L273 TraceCheckUtils]: 17: Hoare triple {3718#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3719#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:03,724 INFO L273 TraceCheckUtils]: 18: Hoare triple {3719#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3720#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:03,725 INFO L273 TraceCheckUtils]: 19: Hoare triple {3720#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3721#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:03,726 INFO L273 TraceCheckUtils]: 20: Hoare triple {3721#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3722#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:03,727 INFO L273 TraceCheckUtils]: 21: Hoare triple {3722#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {3723#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:03,728 INFO L273 TraceCheckUtils]: 22: Hoare triple {3723#(<= main_~i~0 16)} assume !(~i~0 < 100000); {3706#false} is VALID [2018-11-23 12:10:03,728 INFO L273 TraceCheckUtils]: 23: Hoare triple {3706#false} havoc ~x~0;~x~0 := 0; {3706#false} is VALID [2018-11-23 12:10:03,728 INFO L273 TraceCheckUtils]: 24: Hoare triple {3706#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {3706#false} is VALID [2018-11-23 12:10:03,728 INFO L256 TraceCheckUtils]: 25: Hoare triple {3706#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {3706#false} is VALID [2018-11-23 12:10:03,729 INFO L273 TraceCheckUtils]: 26: Hoare triple {3706#false} ~cond := #in~cond; {3706#false} is VALID [2018-11-23 12:10:03,729 INFO L273 TraceCheckUtils]: 27: Hoare triple {3706#false} assume 0 == ~cond; {3706#false} is VALID [2018-11-23 12:10:03,729 INFO L273 TraceCheckUtils]: 28: Hoare triple {3706#false} assume !false; {3706#false} is VALID [2018-11-23 12:10:03,730 INFO L134 CoverageAnalysis]: Checked inductivity of 136 backedges. 0 proven. 136 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:03,749 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:03,749 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [19, 19] total 20 [2018-11-23 12:10:03,750 INFO L78 Accepts]: Start accepts. Automaton has 20 states. Word has length 29 [2018-11-23 12:10:03,750 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:03,750 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 20 states. [2018-11-23 12:10:03,775 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 31 edges. 31 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:03,775 INFO L459 AbstractCegarLoop]: Interpolant automaton has 20 states [2018-11-23 12:10:03,775 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 20 interpolants. [2018-11-23 12:10:03,776 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=190, Invalid=190, Unknown=0, NotChecked=0, Total=380 [2018-11-23 12:10:03,776 INFO L87 Difference]: Start difference. First operand 34 states and 35 transitions. Second operand 20 states. [2018-11-23 12:10:04,004 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:04,004 INFO L93 Difference]: Finished difference Result 46 states and 48 transitions. [2018-11-23 12:10:04,004 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 19 states. [2018-11-23 12:10:04,004 INFO L78 Accepts]: Start accepts. Automaton has 20 states. Word has length 29 [2018-11-23 12:10:04,005 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:04,005 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 20 states. [2018-11-23 12:10:04,007 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 19 states to 19 states and 48 transitions. [2018-11-23 12:10:04,007 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 20 states. [2018-11-23 12:10:04,008 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 19 states to 19 states and 48 transitions. [2018-11-23 12:10:04,008 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 19 states and 48 transitions. [2018-11-23 12:10:04,410 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:10:04,411 INFO L225 Difference]: With dead ends: 46 [2018-11-23 12:10:04,411 INFO L226 Difference]: Without dead ends: 35 [2018-11-23 12:10:04,412 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 47 GetRequests, 29 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:10:04,412 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 35 states. [2018-11-23 12:10:04,431 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 35 to 35. [2018-11-23 12:10:04,431 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:04,431 INFO L82 GeneralOperation]: Start isEquivalent. First operand 35 states. Second operand 35 states. [2018-11-23 12:10:04,432 INFO L74 IsIncluded]: Start isIncluded. First operand 35 states. Second operand 35 states. [2018-11-23 12:10:04,432 INFO L87 Difference]: Start difference. First operand 35 states. Second operand 35 states. [2018-11-23 12:10:04,433 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:04,433 INFO L93 Difference]: Finished difference Result 35 states and 36 transitions. [2018-11-23 12:10:04,433 INFO L276 IsEmpty]: Start isEmpty. Operand 35 states and 36 transitions. [2018-11-23 12:10:04,434 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:04,434 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:04,434 INFO L74 IsIncluded]: Start isIncluded. First operand 35 states. Second operand 35 states. [2018-11-23 12:10:04,434 INFO L87 Difference]: Start difference. First operand 35 states. Second operand 35 states. [2018-11-23 12:10:04,435 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:04,435 INFO L93 Difference]: Finished difference Result 35 states and 36 transitions. [2018-11-23 12:10:04,435 INFO L276 IsEmpty]: Start isEmpty. Operand 35 states and 36 transitions. [2018-11-23 12:10:04,435 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:04,435 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:04,435 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:04,436 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:04,436 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 35 states. [2018-11-23 12:10:04,436 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 35 states to 35 states and 36 transitions. [2018-11-23 12:10:04,437 INFO L78 Accepts]: Start accepts. Automaton has 35 states and 36 transitions. Word has length 29 [2018-11-23 12:10:04,437 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:04,437 INFO L480 AbstractCegarLoop]: Abstraction has 35 states and 36 transitions. [2018-11-23 12:10:04,437 INFO L481 AbstractCegarLoop]: Interpolant automaton has 20 states. [2018-11-23 12:10:04,437 INFO L276 IsEmpty]: Start isEmpty. Operand 35 states and 36 transitions. [2018-11-23 12:10:04,437 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 31 [2018-11-23 12:10:04,437 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:04,438 INFO L402 BasicCegarLoop]: trace histogram [17, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:04,438 INFO L423 AbstractCegarLoop]: === Iteration 19 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:04,438 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:04,438 INFO L82 PathProgramCache]: Analyzing trace with hash -1062387090, now seen corresponding path program 17 times [2018-11-23 12:10:04,438 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:04,438 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:04,439 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:04,439 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:04,439 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:04,454 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:05,458 INFO L256 TraceCheckUtils]: 0: Hoare triple {4015#true} call ULTIMATE.init(); {4015#true} is VALID [2018-11-23 12:10:05,458 INFO L273 TraceCheckUtils]: 1: Hoare triple {4015#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {4015#true} is VALID [2018-11-23 12:10:05,458 INFO L273 TraceCheckUtils]: 2: Hoare triple {4015#true} assume true; {4015#true} is VALID [2018-11-23 12:10:05,459 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {4015#true} {4015#true} #48#return; {4015#true} is VALID [2018-11-23 12:10:05,459 INFO L256 TraceCheckUtils]: 4: Hoare triple {4015#true} call #t~ret6 := main(); {4015#true} is VALID [2018-11-23 12:10:05,460 INFO L273 TraceCheckUtils]: 5: Hoare triple {4015#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {4017#(= main_~i~0 0)} is VALID [2018-11-23 12:10:05,460 INFO L273 TraceCheckUtils]: 6: Hoare triple {4017#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4018#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:05,461 INFO L273 TraceCheckUtils]: 7: Hoare triple {4018#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4019#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:05,462 INFO L273 TraceCheckUtils]: 8: Hoare triple {4019#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4020#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:05,463 INFO L273 TraceCheckUtils]: 9: Hoare triple {4020#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4021#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:05,464 INFO L273 TraceCheckUtils]: 10: Hoare triple {4021#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4022#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:05,465 INFO L273 TraceCheckUtils]: 11: Hoare triple {4022#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4023#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:05,466 INFO L273 TraceCheckUtils]: 12: Hoare triple {4023#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4024#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:05,467 INFO L273 TraceCheckUtils]: 13: Hoare triple {4024#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4025#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:05,468 INFO L273 TraceCheckUtils]: 14: Hoare triple {4025#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4026#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:05,469 INFO L273 TraceCheckUtils]: 15: Hoare triple {4026#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4027#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:05,470 INFO L273 TraceCheckUtils]: 16: Hoare triple {4027#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4028#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:05,472 INFO L273 TraceCheckUtils]: 17: Hoare triple {4028#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4029#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:05,473 INFO L273 TraceCheckUtils]: 18: Hoare triple {4029#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4030#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:05,474 INFO L273 TraceCheckUtils]: 19: Hoare triple {4030#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4031#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:05,475 INFO L273 TraceCheckUtils]: 20: Hoare triple {4031#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4032#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:05,476 INFO L273 TraceCheckUtils]: 21: Hoare triple {4032#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4033#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:05,477 INFO L273 TraceCheckUtils]: 22: Hoare triple {4033#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4034#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:05,478 INFO L273 TraceCheckUtils]: 23: Hoare triple {4034#(<= main_~i~0 17)} assume !(~i~0 < 100000); {4016#false} is VALID [2018-11-23 12:10:05,478 INFO L273 TraceCheckUtils]: 24: Hoare triple {4016#false} havoc ~x~0;~x~0 := 0; {4016#false} is VALID [2018-11-23 12:10:05,478 INFO L273 TraceCheckUtils]: 25: Hoare triple {4016#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {4016#false} is VALID [2018-11-23 12:10:05,478 INFO L256 TraceCheckUtils]: 26: Hoare triple {4016#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {4016#false} is VALID [2018-11-23 12:10:05,479 INFO L273 TraceCheckUtils]: 27: Hoare triple {4016#false} ~cond := #in~cond; {4016#false} is VALID [2018-11-23 12:10:05,479 INFO L273 TraceCheckUtils]: 28: Hoare triple {4016#false} assume 0 == ~cond; {4016#false} is VALID [2018-11-23 12:10:05,479 INFO L273 TraceCheckUtils]: 29: Hoare triple {4016#false} assume !false; {4016#false} is VALID [2018-11-23 12:10:05,480 INFO L134 CoverageAnalysis]: Checked inductivity of 153 backedges. 0 proven. 153 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:05,481 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:05,481 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 18 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 18 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:05,491 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:10:06,450 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 10 check-sat command(s) [2018-11-23 12:10:06,451 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:06,461 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:06,462 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:06,659 INFO L256 TraceCheckUtils]: 0: Hoare triple {4015#true} call ULTIMATE.init(); {4015#true} is VALID [2018-11-23 12:10:06,660 INFO L273 TraceCheckUtils]: 1: Hoare triple {4015#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {4015#true} is VALID [2018-11-23 12:10:06,660 INFO L273 TraceCheckUtils]: 2: Hoare triple {4015#true} assume true; {4015#true} is VALID [2018-11-23 12:10:06,660 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {4015#true} {4015#true} #48#return; {4015#true} is VALID [2018-11-23 12:10:06,660 INFO L256 TraceCheckUtils]: 4: Hoare triple {4015#true} call #t~ret6 := main(); {4015#true} is VALID [2018-11-23 12:10:06,661 INFO L273 TraceCheckUtils]: 5: Hoare triple {4015#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {4053#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:06,662 INFO L273 TraceCheckUtils]: 6: Hoare triple {4053#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4018#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:06,663 INFO L273 TraceCheckUtils]: 7: Hoare triple {4018#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4019#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:06,663 INFO L273 TraceCheckUtils]: 8: Hoare triple {4019#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4020#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:06,664 INFO L273 TraceCheckUtils]: 9: Hoare triple {4020#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4021#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:06,666 INFO L273 TraceCheckUtils]: 10: Hoare triple {4021#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4022#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:06,667 INFO L273 TraceCheckUtils]: 11: Hoare triple {4022#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4023#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:06,668 INFO L273 TraceCheckUtils]: 12: Hoare triple {4023#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4024#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:06,669 INFO L273 TraceCheckUtils]: 13: Hoare triple {4024#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4025#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:06,670 INFO L273 TraceCheckUtils]: 14: Hoare triple {4025#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4026#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:06,671 INFO L273 TraceCheckUtils]: 15: Hoare triple {4026#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4027#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:06,672 INFO L273 TraceCheckUtils]: 16: Hoare triple {4027#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4028#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:06,673 INFO L273 TraceCheckUtils]: 17: Hoare triple {4028#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4029#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:06,674 INFO L273 TraceCheckUtils]: 18: Hoare triple {4029#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4030#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:06,675 INFO L273 TraceCheckUtils]: 19: Hoare triple {4030#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4031#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:06,676 INFO L273 TraceCheckUtils]: 20: Hoare triple {4031#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4032#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:06,677 INFO L273 TraceCheckUtils]: 21: Hoare triple {4032#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4033#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:06,678 INFO L273 TraceCheckUtils]: 22: Hoare triple {4033#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4034#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:06,678 INFO L273 TraceCheckUtils]: 23: Hoare triple {4034#(<= main_~i~0 17)} assume !(~i~0 < 100000); {4016#false} is VALID [2018-11-23 12:10:06,679 INFO L273 TraceCheckUtils]: 24: Hoare triple {4016#false} havoc ~x~0;~x~0 := 0; {4016#false} is VALID [2018-11-23 12:10:06,679 INFO L273 TraceCheckUtils]: 25: Hoare triple {4016#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {4016#false} is VALID [2018-11-23 12:10:06,679 INFO L256 TraceCheckUtils]: 26: Hoare triple {4016#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {4016#false} is VALID [2018-11-23 12:10:06,679 INFO L273 TraceCheckUtils]: 27: Hoare triple {4016#false} ~cond := #in~cond; {4016#false} is VALID [2018-11-23 12:10:06,680 INFO L273 TraceCheckUtils]: 28: Hoare triple {4016#false} assume 0 == ~cond; {4016#false} is VALID [2018-11-23 12:10:06,680 INFO L273 TraceCheckUtils]: 29: Hoare triple {4016#false} assume !false; {4016#false} is VALID [2018-11-23 12:10:06,681 INFO L134 CoverageAnalysis]: Checked inductivity of 153 backedges. 0 proven. 153 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:06,702 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:06,702 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [20, 20] total 21 [2018-11-23 12:10:06,703 INFO L78 Accepts]: Start accepts. Automaton has 21 states. Word has length 30 [2018-11-23 12:10:06,703 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:06,703 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 21 states. [2018-11-23 12:10:06,730 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 32 edges. 32 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:06,730 INFO L459 AbstractCegarLoop]: Interpolant automaton has 21 states [2018-11-23 12:10:06,731 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 21 interpolants. [2018-11-23 12:10:06,731 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=210, Invalid=210, Unknown=0, NotChecked=0, Total=420 [2018-11-23 12:10:06,732 INFO L87 Difference]: Start difference. First operand 35 states and 36 transitions. Second operand 21 states. [2018-11-23 12:10:06,857 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:06,857 INFO L93 Difference]: Finished difference Result 47 states and 49 transitions. [2018-11-23 12:10:06,858 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 20 states. [2018-11-23 12:10:06,858 INFO L78 Accepts]: Start accepts. Automaton has 21 states. Word has length 30 [2018-11-23 12:10:06,858 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:06,858 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 21 states. [2018-11-23 12:10:06,860 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 20 states to 20 states and 49 transitions. [2018-11-23 12:10:06,860 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 21 states. [2018-11-23 12:10:06,861 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 20 states to 20 states and 49 transitions. [2018-11-23 12:10:06,861 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 20 states and 49 transitions. [2018-11-23 12:10:07,375 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 49 edges. 49 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:07,375 INFO L225 Difference]: With dead ends: 47 [2018-11-23 12:10:07,376 INFO L226 Difference]: Without dead ends: 36 [2018-11-23 12:10:07,376 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 49 GetRequests, 30 SyntacticMatches, 0 SemanticMatches, 19 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 32 ImplicationChecksByTransitivity, 0.7s TimeCoverageRelationStatistics Valid=210, Invalid=210, Unknown=0, NotChecked=0, Total=420 [2018-11-23 12:10:07,376 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 36 states. [2018-11-23 12:10:07,407 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 36 to 36. [2018-11-23 12:10:07,407 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:07,407 INFO L82 GeneralOperation]: Start isEquivalent. First operand 36 states. Second operand 36 states. [2018-11-23 12:10:07,407 INFO L74 IsIncluded]: Start isIncluded. First operand 36 states. Second operand 36 states. [2018-11-23 12:10:07,407 INFO L87 Difference]: Start difference. First operand 36 states. Second operand 36 states. [2018-11-23 12:10:07,408 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:07,408 INFO L93 Difference]: Finished difference Result 36 states and 37 transitions. [2018-11-23 12:10:07,408 INFO L276 IsEmpty]: Start isEmpty. Operand 36 states and 37 transitions. [2018-11-23 12:10:07,408 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:07,409 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:07,409 INFO L74 IsIncluded]: Start isIncluded. First operand 36 states. Second operand 36 states. [2018-11-23 12:10:07,409 INFO L87 Difference]: Start difference. First operand 36 states. Second operand 36 states. [2018-11-23 12:10:07,409 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:07,409 INFO L93 Difference]: Finished difference Result 36 states and 37 transitions. [2018-11-23 12:10:07,410 INFO L276 IsEmpty]: Start isEmpty. Operand 36 states and 37 transitions. [2018-11-23 12:10:07,410 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:07,410 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:07,410 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:07,410 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:07,410 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 36 states. [2018-11-23 12:10:07,411 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 36 states to 36 states and 37 transitions. [2018-11-23 12:10:07,411 INFO L78 Accepts]: Start accepts. Automaton has 36 states and 37 transitions. Word has length 30 [2018-11-23 12:10:07,411 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:07,411 INFO L480 AbstractCegarLoop]: Abstraction has 36 states and 37 transitions. [2018-11-23 12:10:07,411 INFO L481 AbstractCegarLoop]: Interpolant automaton has 21 states. [2018-11-23 12:10:07,411 INFO L276 IsEmpty]: Start isEmpty. Operand 36 states and 37 transitions. [2018-11-23 12:10:07,412 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 32 [2018-11-23 12:10:07,412 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:07,412 INFO L402 BasicCegarLoop]: trace histogram [18, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:07,412 INFO L423 AbstractCegarLoop]: === Iteration 20 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:07,412 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:07,413 INFO L82 PathProgramCache]: Analyzing trace with hash -665340110, now seen corresponding path program 18 times [2018-11-23 12:10:07,413 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:07,413 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:07,414 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:07,414 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:07,414 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:07,428 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:07,754 INFO L256 TraceCheckUtils]: 0: Hoare triple {4335#true} call ULTIMATE.init(); {4335#true} is VALID [2018-11-23 12:10:07,754 INFO L273 TraceCheckUtils]: 1: Hoare triple {4335#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {4335#true} is VALID [2018-11-23 12:10:07,754 INFO L273 TraceCheckUtils]: 2: Hoare triple {4335#true} assume true; {4335#true} is VALID [2018-11-23 12:10:07,754 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {4335#true} {4335#true} #48#return; {4335#true} is VALID [2018-11-23 12:10:07,755 INFO L256 TraceCheckUtils]: 4: Hoare triple {4335#true} call #t~ret6 := main(); {4335#true} is VALID [2018-11-23 12:10:07,772 INFO L273 TraceCheckUtils]: 5: Hoare triple {4335#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {4337#(= main_~i~0 0)} is VALID [2018-11-23 12:10:07,781 INFO L273 TraceCheckUtils]: 6: Hoare triple {4337#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4338#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:07,796 INFO L273 TraceCheckUtils]: 7: Hoare triple {4338#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4339#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:07,810 INFO L273 TraceCheckUtils]: 8: Hoare triple {4339#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4340#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:07,826 INFO L273 TraceCheckUtils]: 9: Hoare triple {4340#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4341#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:07,843 INFO L273 TraceCheckUtils]: 10: Hoare triple {4341#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4342#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:07,852 INFO L273 TraceCheckUtils]: 11: Hoare triple {4342#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4343#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:07,863 INFO L273 TraceCheckUtils]: 12: Hoare triple {4343#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4344#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:07,864 INFO L273 TraceCheckUtils]: 13: Hoare triple {4344#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4345#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:07,865 INFO L273 TraceCheckUtils]: 14: Hoare triple {4345#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4346#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:07,867 INFO L273 TraceCheckUtils]: 15: Hoare triple {4346#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4347#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:07,867 INFO L273 TraceCheckUtils]: 16: Hoare triple {4347#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4348#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:07,869 INFO L273 TraceCheckUtils]: 17: Hoare triple {4348#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4349#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:07,870 INFO L273 TraceCheckUtils]: 18: Hoare triple {4349#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4350#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:07,871 INFO L273 TraceCheckUtils]: 19: Hoare triple {4350#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4351#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:07,872 INFO L273 TraceCheckUtils]: 20: Hoare triple {4351#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4352#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:07,873 INFO L273 TraceCheckUtils]: 21: Hoare triple {4352#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4353#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:07,874 INFO L273 TraceCheckUtils]: 22: Hoare triple {4353#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4354#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:07,875 INFO L273 TraceCheckUtils]: 23: Hoare triple {4354#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4355#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:07,876 INFO L273 TraceCheckUtils]: 24: Hoare triple {4355#(<= main_~i~0 18)} assume !(~i~0 < 100000); {4336#false} is VALID [2018-11-23 12:10:07,876 INFO L273 TraceCheckUtils]: 25: Hoare triple {4336#false} havoc ~x~0;~x~0 := 0; {4336#false} is VALID [2018-11-23 12:10:07,876 INFO L273 TraceCheckUtils]: 26: Hoare triple {4336#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {4336#false} is VALID [2018-11-23 12:10:07,877 INFO L256 TraceCheckUtils]: 27: Hoare triple {4336#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {4336#false} is VALID [2018-11-23 12:10:07,877 INFO L273 TraceCheckUtils]: 28: Hoare triple {4336#false} ~cond := #in~cond; {4336#false} is VALID [2018-11-23 12:10:07,877 INFO L273 TraceCheckUtils]: 29: Hoare triple {4336#false} assume 0 == ~cond; {4336#false} is VALID [2018-11-23 12:10:07,877 INFO L273 TraceCheckUtils]: 30: Hoare triple {4336#false} assume !false; {4336#false} is VALID [2018-11-23 12:10:07,879 INFO L134 CoverageAnalysis]: Checked inductivity of 171 backedges. 0 proven. 171 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:07,879 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:07,879 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 19 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 19 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:07,887 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE [2018-11-23 12:10:08,577 INFO L249 tOrderPrioritization]: Assert order MIX_INSIDE_OUTSIDE issued 10 check-sat command(s) [2018-11-23 12:10:08,577 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:08,594 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:08,595 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:08,892 INFO L256 TraceCheckUtils]: 0: Hoare triple {4335#true} call ULTIMATE.init(); {4335#true} is VALID [2018-11-23 12:10:08,892 INFO L273 TraceCheckUtils]: 1: Hoare triple {4335#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {4335#true} is VALID [2018-11-23 12:10:08,892 INFO L273 TraceCheckUtils]: 2: Hoare triple {4335#true} assume true; {4335#true} is VALID [2018-11-23 12:10:08,892 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {4335#true} {4335#true} #48#return; {4335#true} is VALID [2018-11-23 12:10:08,892 INFO L256 TraceCheckUtils]: 4: Hoare triple {4335#true} call #t~ret6 := main(); {4335#true} is VALID [2018-11-23 12:10:08,893 INFO L273 TraceCheckUtils]: 5: Hoare triple {4335#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {4374#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:08,894 INFO L273 TraceCheckUtils]: 6: Hoare triple {4374#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4338#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:08,895 INFO L273 TraceCheckUtils]: 7: Hoare triple {4338#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4339#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:08,895 INFO L273 TraceCheckUtils]: 8: Hoare triple {4339#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4340#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:08,896 INFO L273 TraceCheckUtils]: 9: Hoare triple {4340#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4341#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:08,897 INFO L273 TraceCheckUtils]: 10: Hoare triple {4341#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4342#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:08,898 INFO L273 TraceCheckUtils]: 11: Hoare triple {4342#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4343#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:08,899 INFO L273 TraceCheckUtils]: 12: Hoare triple {4343#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4344#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:08,900 INFO L273 TraceCheckUtils]: 13: Hoare triple {4344#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4345#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:08,901 INFO L273 TraceCheckUtils]: 14: Hoare triple {4345#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4346#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:08,902 INFO L273 TraceCheckUtils]: 15: Hoare triple {4346#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4347#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:08,903 INFO L273 TraceCheckUtils]: 16: Hoare triple {4347#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4348#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:08,904 INFO L273 TraceCheckUtils]: 17: Hoare triple {4348#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4349#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:08,905 INFO L273 TraceCheckUtils]: 18: Hoare triple {4349#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4350#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:08,907 INFO L273 TraceCheckUtils]: 19: Hoare triple {4350#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4351#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:08,908 INFO L273 TraceCheckUtils]: 20: Hoare triple {4351#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4352#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:08,909 INFO L273 TraceCheckUtils]: 21: Hoare triple {4352#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4353#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:08,910 INFO L273 TraceCheckUtils]: 22: Hoare triple {4353#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4354#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:08,911 INFO L273 TraceCheckUtils]: 23: Hoare triple {4354#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4355#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:08,912 INFO L273 TraceCheckUtils]: 24: Hoare triple {4355#(<= main_~i~0 18)} assume !(~i~0 < 100000); {4336#false} is VALID [2018-11-23 12:10:08,912 INFO L273 TraceCheckUtils]: 25: Hoare triple {4336#false} havoc ~x~0;~x~0 := 0; {4336#false} is VALID [2018-11-23 12:10:08,912 INFO L273 TraceCheckUtils]: 26: Hoare triple {4336#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {4336#false} is VALID [2018-11-23 12:10:08,912 INFO L256 TraceCheckUtils]: 27: Hoare triple {4336#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {4336#false} is VALID [2018-11-23 12:10:08,913 INFO L273 TraceCheckUtils]: 28: Hoare triple {4336#false} ~cond := #in~cond; {4336#false} is VALID [2018-11-23 12:10:08,913 INFO L273 TraceCheckUtils]: 29: Hoare triple {4336#false} assume 0 == ~cond; {4336#false} is VALID [2018-11-23 12:10:08,913 INFO L273 TraceCheckUtils]: 30: Hoare triple {4336#false} assume !false; {4336#false} is VALID [2018-11-23 12:10:08,914 INFO L134 CoverageAnalysis]: Checked inductivity of 171 backedges. 0 proven. 171 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:08,936 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:08,937 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [21, 21] total 22 [2018-11-23 12:10:08,937 INFO L78 Accepts]: Start accepts. Automaton has 22 states. Word has length 31 [2018-11-23 12:10:08,937 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:08,937 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 22 states. [2018-11-23 12:10:08,962 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:10:08,962 INFO L459 AbstractCegarLoop]: Interpolant automaton has 22 states [2018-11-23 12:10:08,963 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 22 interpolants. [2018-11-23 12:10:08,963 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=231, Invalid=231, Unknown=0, NotChecked=0, Total=462 [2018-11-23 12:10:08,964 INFO L87 Difference]: Start difference. First operand 36 states and 37 transitions. Second operand 22 states. [2018-11-23 12:10:09,118 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:09,119 INFO L93 Difference]: Finished difference Result 48 states and 50 transitions. [2018-11-23 12:10:09,119 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 21 states. [2018-11-23 12:10:09,119 INFO L78 Accepts]: Start accepts. Automaton has 22 states. Word has length 31 [2018-11-23 12:10:09,120 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:09,120 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 22 states. [2018-11-23 12:10:09,121 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 21 states to 21 states and 50 transitions. [2018-11-23 12:10:09,122 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 22 states. [2018-11-23 12:10:09,123 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 21 states to 21 states and 50 transitions. [2018-11-23 12:10:09,123 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 21 states and 50 transitions. [2018-11-23 12:10:09,499 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 50 edges. 50 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:09,500 INFO L225 Difference]: With dead ends: 48 [2018-11-23 12:10:09,500 INFO L226 Difference]: Without dead ends: 37 [2018-11-23 12:10:09,501 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 51 GetRequests, 31 SyntacticMatches, 0 SemanticMatches, 20 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 34 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=231, Invalid=231, Unknown=0, NotChecked=0, Total=462 [2018-11-23 12:10:09,501 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 37 states. [2018-11-23 12:10:09,522 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 37 to 37. [2018-11-23 12:10:09,522 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:09,522 INFO L82 GeneralOperation]: Start isEquivalent. First operand 37 states. Second operand 37 states. [2018-11-23 12:10:09,523 INFO L74 IsIncluded]: Start isIncluded. First operand 37 states. Second operand 37 states. [2018-11-23 12:10:09,523 INFO L87 Difference]: Start difference. First operand 37 states. Second operand 37 states. [2018-11-23 12:10:09,524 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:09,525 INFO L93 Difference]: Finished difference Result 37 states and 38 transitions. [2018-11-23 12:10:09,525 INFO L276 IsEmpty]: Start isEmpty. Operand 37 states and 38 transitions. [2018-11-23 12:10:09,525 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:09,525 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:09,525 INFO L74 IsIncluded]: Start isIncluded. First operand 37 states. Second operand 37 states. [2018-11-23 12:10:09,525 INFO L87 Difference]: Start difference. First operand 37 states. Second operand 37 states. [2018-11-23 12:10:09,526 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:09,526 INFO L93 Difference]: Finished difference Result 37 states and 38 transitions. [2018-11-23 12:10:09,527 INFO L276 IsEmpty]: Start isEmpty. Operand 37 states and 38 transitions. [2018-11-23 12:10:09,527 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:09,527 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:09,527 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:09,527 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:09,527 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 37 states. [2018-11-23 12:10:09,528 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 37 states to 37 states and 38 transitions. [2018-11-23 12:10:09,528 INFO L78 Accepts]: Start accepts. Automaton has 37 states and 38 transitions. Word has length 31 [2018-11-23 12:10:09,528 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:09,529 INFO L480 AbstractCegarLoop]: Abstraction has 37 states and 38 transitions. [2018-11-23 12:10:09,529 INFO L481 AbstractCegarLoop]: Interpolant automaton has 22 states. [2018-11-23 12:10:09,529 INFO L276 IsEmpty]: Start isEmpty. Operand 37 states and 38 transitions. [2018-11-23 12:10:09,529 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 33 [2018-11-23 12:10:09,529 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:09,529 INFO L402 BasicCegarLoop]: trace histogram [19, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:09,530 INFO L423 AbstractCegarLoop]: === Iteration 21 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:09,530 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:09,530 INFO L82 PathProgramCache]: Analyzing trace with hash -1241785618, now seen corresponding path program 19 times [2018-11-23 12:10:09,530 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:09,530 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:09,531 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:09,531 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:09,531 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:09,547 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:09,912 INFO L256 TraceCheckUtils]: 0: Hoare triple {4665#true} call ULTIMATE.init(); {4665#true} is VALID [2018-11-23 12:10:09,913 INFO L273 TraceCheckUtils]: 1: Hoare triple {4665#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {4665#true} is VALID [2018-11-23 12:10:09,913 INFO L273 TraceCheckUtils]: 2: Hoare triple {4665#true} assume true; {4665#true} is VALID [2018-11-23 12:10:09,913 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {4665#true} {4665#true} #48#return; {4665#true} is VALID [2018-11-23 12:10:09,913 INFO L256 TraceCheckUtils]: 4: Hoare triple {4665#true} call #t~ret6 := main(); {4665#true} is VALID [2018-11-23 12:10:09,914 INFO L273 TraceCheckUtils]: 5: Hoare triple {4665#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {4667#(= main_~i~0 0)} is VALID [2018-11-23 12:10:09,914 INFO L273 TraceCheckUtils]: 6: Hoare triple {4667#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4668#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:09,915 INFO L273 TraceCheckUtils]: 7: Hoare triple {4668#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4669#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:09,917 INFO L273 TraceCheckUtils]: 8: Hoare triple {4669#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4670#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:09,918 INFO L273 TraceCheckUtils]: 9: Hoare triple {4670#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4671#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:09,919 INFO L273 TraceCheckUtils]: 10: Hoare triple {4671#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4672#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:09,920 INFO L273 TraceCheckUtils]: 11: Hoare triple {4672#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4673#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:09,921 INFO L273 TraceCheckUtils]: 12: Hoare triple {4673#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4674#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:09,922 INFO L273 TraceCheckUtils]: 13: Hoare triple {4674#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4675#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:09,923 INFO L273 TraceCheckUtils]: 14: Hoare triple {4675#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4676#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:09,924 INFO L273 TraceCheckUtils]: 15: Hoare triple {4676#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4677#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:09,925 INFO L273 TraceCheckUtils]: 16: Hoare triple {4677#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4678#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:09,926 INFO L273 TraceCheckUtils]: 17: Hoare triple {4678#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4679#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:09,928 INFO L273 TraceCheckUtils]: 18: Hoare triple {4679#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4680#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:09,929 INFO L273 TraceCheckUtils]: 19: Hoare triple {4680#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4681#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:09,930 INFO L273 TraceCheckUtils]: 20: Hoare triple {4681#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4682#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:09,931 INFO L273 TraceCheckUtils]: 21: Hoare triple {4682#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4683#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:09,932 INFO L273 TraceCheckUtils]: 22: Hoare triple {4683#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4684#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:09,933 INFO L273 TraceCheckUtils]: 23: Hoare triple {4684#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4685#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:09,934 INFO L273 TraceCheckUtils]: 24: Hoare triple {4685#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4686#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:09,935 INFO L273 TraceCheckUtils]: 25: Hoare triple {4686#(<= main_~i~0 19)} assume !(~i~0 < 100000); {4666#false} is VALID [2018-11-23 12:10:09,935 INFO L273 TraceCheckUtils]: 26: Hoare triple {4666#false} havoc ~x~0;~x~0 := 0; {4666#false} is VALID [2018-11-23 12:10:09,935 INFO L273 TraceCheckUtils]: 27: Hoare triple {4666#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {4666#false} is VALID [2018-11-23 12:10:09,935 INFO L256 TraceCheckUtils]: 28: Hoare triple {4666#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {4666#false} is VALID [2018-11-23 12:10:09,936 INFO L273 TraceCheckUtils]: 29: Hoare triple {4666#false} ~cond := #in~cond; {4666#false} is VALID [2018-11-23 12:10:09,936 INFO L273 TraceCheckUtils]: 30: Hoare triple {4666#false} assume 0 == ~cond; {4666#false} is VALID [2018-11-23 12:10:09,936 INFO L273 TraceCheckUtils]: 31: Hoare triple {4666#false} assume !false; {4666#false} is VALID [2018-11-23 12:10:09,938 INFO L134 CoverageAnalysis]: Checked inductivity of 190 backedges. 0 proven. 190 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:09,938 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:09,938 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 20 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 20 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:09,951 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:10:09,974 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:09,987 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:09,988 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:10,162 INFO L256 TraceCheckUtils]: 0: Hoare triple {4665#true} call ULTIMATE.init(); {4665#true} is VALID [2018-11-23 12:10:10,162 INFO L273 TraceCheckUtils]: 1: Hoare triple {4665#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {4665#true} is VALID [2018-11-23 12:10:10,163 INFO L273 TraceCheckUtils]: 2: Hoare triple {4665#true} assume true; {4665#true} is VALID [2018-11-23 12:10:10,163 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {4665#true} {4665#true} #48#return; {4665#true} is VALID [2018-11-23 12:10:10,163 INFO L256 TraceCheckUtils]: 4: Hoare triple {4665#true} call #t~ret6 := main(); {4665#true} is VALID [2018-11-23 12:10:10,164 INFO L273 TraceCheckUtils]: 5: Hoare triple {4665#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {4705#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:10,165 INFO L273 TraceCheckUtils]: 6: Hoare triple {4705#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4668#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:10,166 INFO L273 TraceCheckUtils]: 7: Hoare triple {4668#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4669#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:10,167 INFO L273 TraceCheckUtils]: 8: Hoare triple {4669#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4670#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:10,168 INFO L273 TraceCheckUtils]: 9: Hoare triple {4670#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4671#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:10,169 INFO L273 TraceCheckUtils]: 10: Hoare triple {4671#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4672#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:10,170 INFO L273 TraceCheckUtils]: 11: Hoare triple {4672#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4673#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:10,171 INFO L273 TraceCheckUtils]: 12: Hoare triple {4673#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4674#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:10,173 INFO L273 TraceCheckUtils]: 13: Hoare triple {4674#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4675#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:10,174 INFO L273 TraceCheckUtils]: 14: Hoare triple {4675#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4676#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:10,175 INFO L273 TraceCheckUtils]: 15: Hoare triple {4676#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4677#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:10,176 INFO L273 TraceCheckUtils]: 16: Hoare triple {4677#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4678#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:10,178 INFO L273 TraceCheckUtils]: 17: Hoare triple {4678#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4679#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:10,179 INFO L273 TraceCheckUtils]: 18: Hoare triple {4679#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4680#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:10,180 INFO L273 TraceCheckUtils]: 19: Hoare triple {4680#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4681#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:10,181 INFO L273 TraceCheckUtils]: 20: Hoare triple {4681#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4682#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:10,183 INFO L273 TraceCheckUtils]: 21: Hoare triple {4682#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4683#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:10,184 INFO L273 TraceCheckUtils]: 22: Hoare triple {4683#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4684#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:10,185 INFO L273 TraceCheckUtils]: 23: Hoare triple {4684#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4685#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:10,186 INFO L273 TraceCheckUtils]: 24: Hoare triple {4685#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {4686#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:10,187 INFO L273 TraceCheckUtils]: 25: Hoare triple {4686#(<= main_~i~0 19)} assume !(~i~0 < 100000); {4666#false} is VALID [2018-11-23 12:10:10,188 INFO L273 TraceCheckUtils]: 26: Hoare triple {4666#false} havoc ~x~0;~x~0 := 0; {4666#false} is VALID [2018-11-23 12:10:10,188 INFO L273 TraceCheckUtils]: 27: Hoare triple {4666#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {4666#false} is VALID [2018-11-23 12:10:10,188 INFO L256 TraceCheckUtils]: 28: Hoare triple {4666#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {4666#false} is VALID [2018-11-23 12:10:10,188 INFO L273 TraceCheckUtils]: 29: Hoare triple {4666#false} ~cond := #in~cond; {4666#false} is VALID [2018-11-23 12:10:10,189 INFO L273 TraceCheckUtils]: 30: Hoare triple {4666#false} assume 0 == ~cond; {4666#false} is VALID [2018-11-23 12:10:10,189 INFO L273 TraceCheckUtils]: 31: Hoare triple {4666#false} assume !false; {4666#false} is VALID [2018-11-23 12:10:10,191 INFO L134 CoverageAnalysis]: Checked inductivity of 190 backedges. 0 proven. 190 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:10,210 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:10,210 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [22, 22] total 23 [2018-11-23 12:10:10,211 INFO L78 Accepts]: Start accepts. Automaton has 23 states. Word has length 32 [2018-11-23 12:10:10,211 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:10,211 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 23 states. [2018-11-23 12:10:10,244 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:10:10,244 INFO L459 AbstractCegarLoop]: Interpolant automaton has 23 states [2018-11-23 12:10:10,244 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 23 interpolants. [2018-11-23 12:10:10,245 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=253, Invalid=253, Unknown=0, NotChecked=0, Total=506 [2018-11-23 12:10:10,245 INFO L87 Difference]: Start difference. First operand 37 states and 38 transitions. Second operand 23 states. [2018-11-23 12:10:10,764 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:10,764 INFO L93 Difference]: Finished difference Result 49 states and 51 transitions. [2018-11-23 12:10:10,764 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 22 states. [2018-11-23 12:10:10,767 INFO L78 Accepts]: Start accepts. Automaton has 23 states. Word has length 32 [2018-11-23 12:10:10,767 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:10,767 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 23 states. [2018-11-23 12:10:10,769 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 22 states to 22 states and 51 transitions. [2018-11-23 12:10:10,769 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 23 states. [2018-11-23 12:10:10,770 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 22 states to 22 states and 51 transitions. [2018-11-23 12:10:10,770 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 22 states and 51 transitions. [2018-11-23 12:10:11,404 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 51 edges. 51 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:11,405 INFO L225 Difference]: With dead ends: 49 [2018-11-23 12:10:11,406 INFO L226 Difference]: Without dead ends: 38 [2018-11-23 12:10:11,406 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 53 GetRequests, 32 SyntacticMatches, 0 SemanticMatches, 21 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 36 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=253, Invalid=253, Unknown=0, NotChecked=0, Total=506 [2018-11-23 12:10:11,407 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 38 states. [2018-11-23 12:10:11,702 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 38 to 38. [2018-11-23 12:10:11,702 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:11,702 INFO L82 GeneralOperation]: Start isEquivalent. First operand 38 states. Second operand 38 states. [2018-11-23 12:10:11,702 INFO L74 IsIncluded]: Start isIncluded. First operand 38 states. Second operand 38 states. [2018-11-23 12:10:11,702 INFO L87 Difference]: Start difference. First operand 38 states. Second operand 38 states. [2018-11-23 12:10:11,703 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:11,703 INFO L93 Difference]: Finished difference Result 38 states and 39 transitions. [2018-11-23 12:10:11,704 INFO L276 IsEmpty]: Start isEmpty. Operand 38 states and 39 transitions. [2018-11-23 12:10:11,704 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:11,704 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:11,704 INFO L74 IsIncluded]: Start isIncluded. First operand 38 states. Second operand 38 states. [2018-11-23 12:10:11,704 INFO L87 Difference]: Start difference. First operand 38 states. Second operand 38 states. [2018-11-23 12:10:11,705 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:11,705 INFO L93 Difference]: Finished difference Result 38 states and 39 transitions. [2018-11-23 12:10:11,705 INFO L276 IsEmpty]: Start isEmpty. Operand 38 states and 39 transitions. [2018-11-23 12:10:11,706 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:11,706 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:11,706 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:11,706 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:11,706 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 38 states. [2018-11-23 12:10:11,707 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 38 states to 38 states and 39 transitions. [2018-11-23 12:10:11,707 INFO L78 Accepts]: Start accepts. Automaton has 38 states and 39 transitions. Word has length 32 [2018-11-23 12:10:11,707 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:11,707 INFO L480 AbstractCegarLoop]: Abstraction has 38 states and 39 transitions. [2018-11-23 12:10:11,707 INFO L481 AbstractCegarLoop]: Interpolant automaton has 23 states. [2018-11-23 12:10:11,707 INFO L276 IsEmpty]: Start isEmpty. Operand 38 states and 39 transitions. [2018-11-23 12:10:11,708 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 34 [2018-11-23 12:10:11,708 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:11,708 INFO L402 BasicCegarLoop]: trace histogram [20, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:11,708 INFO L423 AbstractCegarLoop]: === Iteration 22 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:11,708 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:11,708 INFO L82 PathProgramCache]: Analyzing trace with hash -1931727182, now seen corresponding path program 20 times [2018-11-23 12:10:11,708 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:11,709 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:11,709 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:11,709 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:10:11,710 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:11,728 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:12,236 INFO L256 TraceCheckUtils]: 0: Hoare triple {5005#true} call ULTIMATE.init(); {5005#true} is VALID [2018-11-23 12:10:12,236 INFO L273 TraceCheckUtils]: 1: Hoare triple {5005#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {5005#true} is VALID [2018-11-23 12:10:12,236 INFO L273 TraceCheckUtils]: 2: Hoare triple {5005#true} assume true; {5005#true} is VALID [2018-11-23 12:10:12,237 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {5005#true} {5005#true} #48#return; {5005#true} is VALID [2018-11-23 12:10:12,237 INFO L256 TraceCheckUtils]: 4: Hoare triple {5005#true} call #t~ret6 := main(); {5005#true} is VALID [2018-11-23 12:10:12,237 INFO L273 TraceCheckUtils]: 5: Hoare triple {5005#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {5007#(= main_~i~0 0)} is VALID [2018-11-23 12:10:12,238 INFO L273 TraceCheckUtils]: 6: Hoare triple {5007#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5008#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:12,239 INFO L273 TraceCheckUtils]: 7: Hoare triple {5008#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5009#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:12,240 INFO L273 TraceCheckUtils]: 8: Hoare triple {5009#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5010#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:12,241 INFO L273 TraceCheckUtils]: 9: Hoare triple {5010#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5011#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:12,241 INFO L273 TraceCheckUtils]: 10: Hoare triple {5011#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5012#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:12,242 INFO L273 TraceCheckUtils]: 11: Hoare triple {5012#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5013#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:12,243 INFO L273 TraceCheckUtils]: 12: Hoare triple {5013#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5014#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:12,244 INFO L273 TraceCheckUtils]: 13: Hoare triple {5014#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5015#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:12,245 INFO L273 TraceCheckUtils]: 14: Hoare triple {5015#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5016#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:12,246 INFO L273 TraceCheckUtils]: 15: Hoare triple {5016#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5017#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:12,247 INFO L273 TraceCheckUtils]: 16: Hoare triple {5017#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5018#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:12,248 INFO L273 TraceCheckUtils]: 17: Hoare triple {5018#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5019#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:12,249 INFO L273 TraceCheckUtils]: 18: Hoare triple {5019#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5020#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:12,250 INFO L273 TraceCheckUtils]: 19: Hoare triple {5020#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5021#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:12,251 INFO L273 TraceCheckUtils]: 20: Hoare triple {5021#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5022#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:12,252 INFO L273 TraceCheckUtils]: 21: Hoare triple {5022#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5023#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:12,253 INFO L273 TraceCheckUtils]: 22: Hoare triple {5023#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5024#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:12,255 INFO L273 TraceCheckUtils]: 23: Hoare triple {5024#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5025#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:12,256 INFO L273 TraceCheckUtils]: 24: Hoare triple {5025#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5026#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:12,257 INFO L273 TraceCheckUtils]: 25: Hoare triple {5026#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5027#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:12,257 INFO L273 TraceCheckUtils]: 26: Hoare triple {5027#(<= main_~i~0 20)} assume !(~i~0 < 100000); {5006#false} is VALID [2018-11-23 12:10:12,258 INFO L273 TraceCheckUtils]: 27: Hoare triple {5006#false} havoc ~x~0;~x~0 := 0; {5006#false} is VALID [2018-11-23 12:10:12,258 INFO L273 TraceCheckUtils]: 28: Hoare triple {5006#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {5006#false} is VALID [2018-11-23 12:10:12,258 INFO L256 TraceCheckUtils]: 29: Hoare triple {5006#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {5006#false} is VALID [2018-11-23 12:10:12,258 INFO L273 TraceCheckUtils]: 30: Hoare triple {5006#false} ~cond := #in~cond; {5006#false} is VALID [2018-11-23 12:10:12,258 INFO L273 TraceCheckUtils]: 31: Hoare triple {5006#false} assume 0 == ~cond; {5006#false} is VALID [2018-11-23 12:10:12,259 INFO L273 TraceCheckUtils]: 32: Hoare triple {5006#false} assume !false; {5006#false} is VALID [2018-11-23 12:10:12,260 INFO L134 CoverageAnalysis]: Checked inductivity of 210 backedges. 0 proven. 210 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:12,260 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:12,260 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 21 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 21 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:12,270 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:10:12,299 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:10:12,299 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:12,309 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:12,311 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:12,443 INFO L256 TraceCheckUtils]: 0: Hoare triple {5005#true} call ULTIMATE.init(); {5005#true} is VALID [2018-11-23 12:10:12,443 INFO L273 TraceCheckUtils]: 1: Hoare triple {5005#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {5005#true} is VALID [2018-11-23 12:10:12,443 INFO L273 TraceCheckUtils]: 2: Hoare triple {5005#true} assume true; {5005#true} is VALID [2018-11-23 12:10:12,444 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {5005#true} {5005#true} #48#return; {5005#true} is VALID [2018-11-23 12:10:12,444 INFO L256 TraceCheckUtils]: 4: Hoare triple {5005#true} call #t~ret6 := main(); {5005#true} is VALID [2018-11-23 12:10:12,445 INFO L273 TraceCheckUtils]: 5: Hoare triple {5005#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {5046#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:12,446 INFO L273 TraceCheckUtils]: 6: Hoare triple {5046#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5008#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:12,446 INFO L273 TraceCheckUtils]: 7: Hoare triple {5008#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5009#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:12,447 INFO L273 TraceCheckUtils]: 8: Hoare triple {5009#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5010#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:12,448 INFO L273 TraceCheckUtils]: 9: Hoare triple {5010#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5011#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:12,449 INFO L273 TraceCheckUtils]: 10: Hoare triple {5011#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5012#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:12,450 INFO L273 TraceCheckUtils]: 11: Hoare triple {5012#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5013#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:12,451 INFO L273 TraceCheckUtils]: 12: Hoare triple {5013#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5014#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:12,452 INFO L273 TraceCheckUtils]: 13: Hoare triple {5014#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5015#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:12,453 INFO L273 TraceCheckUtils]: 14: Hoare triple {5015#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5016#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:12,454 INFO L273 TraceCheckUtils]: 15: Hoare triple {5016#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5017#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:12,455 INFO L273 TraceCheckUtils]: 16: Hoare triple {5017#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5018#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:12,456 INFO L273 TraceCheckUtils]: 17: Hoare triple {5018#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5019#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:12,457 INFO L273 TraceCheckUtils]: 18: Hoare triple {5019#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5020#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:12,458 INFO L273 TraceCheckUtils]: 19: Hoare triple {5020#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5021#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:12,459 INFO L273 TraceCheckUtils]: 20: Hoare triple {5021#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5022#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:12,460 INFO L273 TraceCheckUtils]: 21: Hoare triple {5022#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5023#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:12,461 INFO L273 TraceCheckUtils]: 22: Hoare triple {5023#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5024#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:12,462 INFO L273 TraceCheckUtils]: 23: Hoare triple {5024#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5025#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:12,463 INFO L273 TraceCheckUtils]: 24: Hoare triple {5025#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5026#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:12,464 INFO L273 TraceCheckUtils]: 25: Hoare triple {5026#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5027#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:12,465 INFO L273 TraceCheckUtils]: 26: Hoare triple {5027#(<= main_~i~0 20)} assume !(~i~0 < 100000); {5006#false} is VALID [2018-11-23 12:10:12,465 INFO L273 TraceCheckUtils]: 27: Hoare triple {5006#false} havoc ~x~0;~x~0 := 0; {5006#false} is VALID [2018-11-23 12:10:12,465 INFO L273 TraceCheckUtils]: 28: Hoare triple {5006#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {5006#false} is VALID [2018-11-23 12:10:12,466 INFO L256 TraceCheckUtils]: 29: Hoare triple {5006#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {5006#false} is VALID [2018-11-23 12:10:12,466 INFO L273 TraceCheckUtils]: 30: Hoare triple {5006#false} ~cond := #in~cond; {5006#false} is VALID [2018-11-23 12:10:12,466 INFO L273 TraceCheckUtils]: 31: Hoare triple {5006#false} assume 0 == ~cond; {5006#false} is VALID [2018-11-23 12:10:12,466 INFO L273 TraceCheckUtils]: 32: Hoare triple {5006#false} assume !false; {5006#false} is VALID [2018-11-23 12:10:12,467 INFO L134 CoverageAnalysis]: Checked inductivity of 210 backedges. 0 proven. 210 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:12,487 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:12,487 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [23, 23] total 24 [2018-11-23 12:10:12,488 INFO L78 Accepts]: Start accepts. Automaton has 24 states. Word has length 33 [2018-11-23 12:10:12,488 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:12,488 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 24 states. [2018-11-23 12:10:12,514 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 35 edges. 35 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:12,514 INFO L459 AbstractCegarLoop]: Interpolant automaton has 24 states [2018-11-23 12:10:12,514 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 24 interpolants. [2018-11-23 12:10:12,515 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=276, Invalid=276, Unknown=0, NotChecked=0, Total=552 [2018-11-23 12:10:12,515 INFO L87 Difference]: Start difference. First operand 38 states and 39 transitions. Second operand 24 states. [2018-11-23 12:10:12,687 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:12,687 INFO L93 Difference]: Finished difference Result 50 states and 52 transitions. [2018-11-23 12:10:12,688 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 23 states. [2018-11-23 12:10:12,688 INFO L78 Accepts]: Start accepts. Automaton has 24 states. Word has length 33 [2018-11-23 12:10:12,688 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:12,688 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 24 states. [2018-11-23 12:10:12,690 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 23 states to 23 states and 52 transitions. [2018-11-23 12:10:12,690 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 24 states. [2018-11-23 12:10:12,691 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 23 states to 23 states and 52 transitions. [2018-11-23 12:10:12,691 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 23 states and 52 transitions. [2018-11-23 12:10:12,750 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 52 edges. 52 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:12,751 INFO L225 Difference]: With dead ends: 50 [2018-11-23 12:10:12,751 INFO L226 Difference]: Without dead ends: 39 [2018-11-23 12:10:12,752 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 55 GetRequests, 33 SyntacticMatches, 0 SemanticMatches, 22 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 38 ImplicationChecksByTransitivity, 0.3s TimeCoverageRelationStatistics Valid=276, Invalid=276, Unknown=0, NotChecked=0, Total=552 [2018-11-23 12:10:12,752 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 39 states. [2018-11-23 12:10:12,870 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 39 to 39. [2018-11-23 12:10:12,871 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:12,871 INFO L82 GeneralOperation]: Start isEquivalent. First operand 39 states. Second operand 39 states. [2018-11-23 12:10:12,871 INFO L74 IsIncluded]: Start isIncluded. First operand 39 states. Second operand 39 states. [2018-11-23 12:10:12,871 INFO L87 Difference]: Start difference. First operand 39 states. Second operand 39 states. [2018-11-23 12:10:12,872 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:12,873 INFO L93 Difference]: Finished difference Result 39 states and 40 transitions. [2018-11-23 12:10:12,873 INFO L276 IsEmpty]: Start isEmpty. Operand 39 states and 40 transitions. [2018-11-23 12:10:12,873 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:12,873 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:12,873 INFO L74 IsIncluded]: Start isIncluded. First operand 39 states. Second operand 39 states. [2018-11-23 12:10:12,873 INFO L87 Difference]: Start difference. First operand 39 states. Second operand 39 states. [2018-11-23 12:10:12,874 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:12,874 INFO L93 Difference]: Finished difference Result 39 states and 40 transitions. [2018-11-23 12:10:12,874 INFO L276 IsEmpty]: Start isEmpty. Operand 39 states and 40 transitions. [2018-11-23 12:10:12,874 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:12,874 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:12,875 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:12,876 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:12,876 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 39 states. [2018-11-23 12:10:12,877 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 39 states to 39 states and 40 transitions. [2018-11-23 12:10:12,877 INFO L78 Accepts]: Start accepts. Automaton has 39 states and 40 transitions. Word has length 33 [2018-11-23 12:10:12,877 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:12,877 INFO L480 AbstractCegarLoop]: Abstraction has 39 states and 40 transitions. [2018-11-23 12:10:12,877 INFO L481 AbstractCegarLoop]: Interpolant automaton has 24 states. [2018-11-23 12:10:12,877 INFO L276 IsEmpty]: Start isEmpty. Operand 39 states and 40 transitions. [2018-11-23 12:10:12,878 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 35 [2018-11-23 12:10:12,878 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:12,878 INFO L402 BasicCegarLoop]: trace histogram [21, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:12,878 INFO L423 AbstractCegarLoop]: === Iteration 23 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:12,878 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:12,879 INFO L82 PathProgramCache]: Analyzing trace with hash -1845079186, now seen corresponding path program 21 times [2018-11-23 12:10:12,880 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:12,880 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:12,880 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:12,881 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:12,881 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:12,902 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:13,814 INFO L256 TraceCheckUtils]: 0: Hoare triple {5355#true} call ULTIMATE.init(); {5355#true} is VALID [2018-11-23 12:10:13,814 INFO L273 TraceCheckUtils]: 1: Hoare triple {5355#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {5355#true} is VALID [2018-11-23 12:10:13,814 INFO L273 TraceCheckUtils]: 2: Hoare triple {5355#true} assume true; {5355#true} is VALID [2018-11-23 12:10:13,814 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {5355#true} {5355#true} #48#return; {5355#true} is VALID [2018-11-23 12:10:13,815 INFO L256 TraceCheckUtils]: 4: Hoare triple {5355#true} call #t~ret6 := main(); {5355#true} is VALID [2018-11-23 12:10:13,816 INFO L273 TraceCheckUtils]: 5: Hoare triple {5355#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {5357#(= main_~i~0 0)} is VALID [2018-11-23 12:10:13,816 INFO L273 TraceCheckUtils]: 6: Hoare triple {5357#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5358#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:13,818 INFO L273 TraceCheckUtils]: 7: Hoare triple {5358#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5359#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:13,819 INFO L273 TraceCheckUtils]: 8: Hoare triple {5359#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5360#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:13,820 INFO L273 TraceCheckUtils]: 9: Hoare triple {5360#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5361#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:13,821 INFO L273 TraceCheckUtils]: 10: Hoare triple {5361#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5362#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:13,823 INFO L273 TraceCheckUtils]: 11: Hoare triple {5362#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5363#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:13,824 INFO L273 TraceCheckUtils]: 12: Hoare triple {5363#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5364#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:13,825 INFO L273 TraceCheckUtils]: 13: Hoare triple {5364#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5365#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:13,825 INFO L273 TraceCheckUtils]: 14: Hoare triple {5365#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5366#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:13,827 INFO L273 TraceCheckUtils]: 15: Hoare triple {5366#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5367#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:13,828 INFO L273 TraceCheckUtils]: 16: Hoare triple {5367#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5368#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:13,833 INFO L273 TraceCheckUtils]: 17: Hoare triple {5368#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5369#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:13,833 INFO L273 TraceCheckUtils]: 18: Hoare triple {5369#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5370#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:13,835 INFO L273 TraceCheckUtils]: 19: Hoare triple {5370#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5371#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:13,835 INFO L273 TraceCheckUtils]: 20: Hoare triple {5371#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5372#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:13,837 INFO L273 TraceCheckUtils]: 21: Hoare triple {5372#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5373#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:13,837 INFO L273 TraceCheckUtils]: 22: Hoare triple {5373#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5374#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:13,839 INFO L273 TraceCheckUtils]: 23: Hoare triple {5374#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5375#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:13,840 INFO L273 TraceCheckUtils]: 24: Hoare triple {5375#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5376#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:13,841 INFO L273 TraceCheckUtils]: 25: Hoare triple {5376#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5377#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:13,842 INFO L273 TraceCheckUtils]: 26: Hoare triple {5377#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5378#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:13,843 INFO L273 TraceCheckUtils]: 27: Hoare triple {5378#(<= main_~i~0 21)} assume !(~i~0 < 100000); {5356#false} is VALID [2018-11-23 12:10:13,843 INFO L273 TraceCheckUtils]: 28: Hoare triple {5356#false} havoc ~x~0;~x~0 := 0; {5356#false} is VALID [2018-11-23 12:10:13,843 INFO L273 TraceCheckUtils]: 29: Hoare triple {5356#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {5356#false} is VALID [2018-11-23 12:10:13,843 INFO L256 TraceCheckUtils]: 30: Hoare triple {5356#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {5356#false} is VALID [2018-11-23 12:10:13,844 INFO L273 TraceCheckUtils]: 31: Hoare triple {5356#false} ~cond := #in~cond; {5356#false} is VALID [2018-11-23 12:10:13,844 INFO L273 TraceCheckUtils]: 32: Hoare triple {5356#false} assume 0 == ~cond; {5356#false} is VALID [2018-11-23 12:10:13,844 INFO L273 TraceCheckUtils]: 33: Hoare triple {5356#false} assume !false; {5356#false} is VALID [2018-11-23 12:10:13,846 INFO L134 CoverageAnalysis]: Checked inductivity of 231 backedges. 0 proven. 231 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:13,846 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:13,846 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 22 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 22 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:13,856 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:10:15,673 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 12 check-sat command(s) [2018-11-23 12:10:15,674 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:15,691 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:15,692 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:15,849 INFO L256 TraceCheckUtils]: 0: Hoare triple {5355#true} call ULTIMATE.init(); {5355#true} is VALID [2018-11-23 12:10:15,850 INFO L273 TraceCheckUtils]: 1: Hoare triple {5355#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {5355#true} is VALID [2018-11-23 12:10:15,850 INFO L273 TraceCheckUtils]: 2: Hoare triple {5355#true} assume true; {5355#true} is VALID [2018-11-23 12:10:15,850 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {5355#true} {5355#true} #48#return; {5355#true} is VALID [2018-11-23 12:10:15,850 INFO L256 TraceCheckUtils]: 4: Hoare triple {5355#true} call #t~ret6 := main(); {5355#true} is VALID [2018-11-23 12:10:15,851 INFO L273 TraceCheckUtils]: 5: Hoare triple {5355#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {5397#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:15,852 INFO L273 TraceCheckUtils]: 6: Hoare triple {5397#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5358#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:15,853 INFO L273 TraceCheckUtils]: 7: Hoare triple {5358#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5359#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:15,853 INFO L273 TraceCheckUtils]: 8: Hoare triple {5359#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5360#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:15,855 INFO L273 TraceCheckUtils]: 9: Hoare triple {5360#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5361#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:15,856 INFO L273 TraceCheckUtils]: 10: Hoare triple {5361#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5362#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:15,857 INFO L273 TraceCheckUtils]: 11: Hoare triple {5362#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5363#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:15,858 INFO L273 TraceCheckUtils]: 12: Hoare triple {5363#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5364#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:15,859 INFO L273 TraceCheckUtils]: 13: Hoare triple {5364#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5365#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:15,860 INFO L273 TraceCheckUtils]: 14: Hoare triple {5365#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5366#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:15,861 INFO L273 TraceCheckUtils]: 15: Hoare triple {5366#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5367#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:15,862 INFO L273 TraceCheckUtils]: 16: Hoare triple {5367#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5368#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:15,863 INFO L273 TraceCheckUtils]: 17: Hoare triple {5368#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5369#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:15,864 INFO L273 TraceCheckUtils]: 18: Hoare triple {5369#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5370#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:15,865 INFO L273 TraceCheckUtils]: 19: Hoare triple {5370#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5371#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:15,867 INFO L273 TraceCheckUtils]: 20: Hoare triple {5371#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5372#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:15,868 INFO L273 TraceCheckUtils]: 21: Hoare triple {5372#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5373#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:15,869 INFO L273 TraceCheckUtils]: 22: Hoare triple {5373#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5374#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:15,870 INFO L273 TraceCheckUtils]: 23: Hoare triple {5374#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5375#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:15,871 INFO L273 TraceCheckUtils]: 24: Hoare triple {5375#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5376#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:15,872 INFO L273 TraceCheckUtils]: 25: Hoare triple {5376#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5377#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:15,873 INFO L273 TraceCheckUtils]: 26: Hoare triple {5377#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5378#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:15,874 INFO L273 TraceCheckUtils]: 27: Hoare triple {5378#(<= main_~i~0 21)} assume !(~i~0 < 100000); {5356#false} is VALID [2018-11-23 12:10:15,874 INFO L273 TraceCheckUtils]: 28: Hoare triple {5356#false} havoc ~x~0;~x~0 := 0; {5356#false} is VALID [2018-11-23 12:10:15,874 INFO L273 TraceCheckUtils]: 29: Hoare triple {5356#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {5356#false} is VALID [2018-11-23 12:10:15,874 INFO L256 TraceCheckUtils]: 30: Hoare triple {5356#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {5356#false} is VALID [2018-11-23 12:10:15,875 INFO L273 TraceCheckUtils]: 31: Hoare triple {5356#false} ~cond := #in~cond; {5356#false} is VALID [2018-11-23 12:10:15,875 INFO L273 TraceCheckUtils]: 32: Hoare triple {5356#false} assume 0 == ~cond; {5356#false} is VALID [2018-11-23 12:10:15,875 INFO L273 TraceCheckUtils]: 33: Hoare triple {5356#false} assume !false; {5356#false} is VALID [2018-11-23 12:10:15,877 INFO L134 CoverageAnalysis]: Checked inductivity of 231 backedges. 0 proven. 231 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:15,897 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:15,897 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [24, 24] total 25 [2018-11-23 12:10:15,898 INFO L78 Accepts]: Start accepts. Automaton has 25 states. Word has length 34 [2018-11-23 12:10:15,898 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:15,898 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 25 states. [2018-11-23 12:10:15,925 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:10:15,925 INFO L459 AbstractCegarLoop]: Interpolant automaton has 25 states [2018-11-23 12:10:15,926 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 25 interpolants. [2018-11-23 12:10:15,926 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=300, Invalid=300, Unknown=0, NotChecked=0, Total=600 [2018-11-23 12:10:15,926 INFO L87 Difference]: Start difference. First operand 39 states and 40 transitions. Second operand 25 states. [2018-11-23 12:10:16,066 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:16,066 INFO L93 Difference]: Finished difference Result 51 states and 53 transitions. [2018-11-23 12:10:16,066 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 24 states. [2018-11-23 12:10:16,066 INFO L78 Accepts]: Start accepts. Automaton has 25 states. Word has length 34 [2018-11-23 12:10:16,067 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:16,067 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 25 states. [2018-11-23 12:10:16,068 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 24 states to 24 states and 53 transitions. [2018-11-23 12:10:16,068 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 25 states. [2018-11-23 12:10:16,068 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 24 states to 24 states and 53 transitions. [2018-11-23 12:10:16,069 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 24 states and 53 transitions. [2018-11-23 12:10:16,113 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:10:16,114 INFO L225 Difference]: With dead ends: 51 [2018-11-23 12:10:16,114 INFO L226 Difference]: Without dead ends: 40 [2018-11-23 12:10:16,115 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 57 GetRequests, 34 SyntacticMatches, 0 SemanticMatches, 23 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 40 ImplicationChecksByTransitivity, 0.7s TimeCoverageRelationStatistics Valid=300, Invalid=300, Unknown=0, NotChecked=0, Total=600 [2018-11-23 12:10:16,116 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 40 states. [2018-11-23 12:10:16,156 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 40 to 40. [2018-11-23 12:10:16,157 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:16,157 INFO L82 GeneralOperation]: Start isEquivalent. First operand 40 states. Second operand 40 states. [2018-11-23 12:10:16,157 INFO L74 IsIncluded]: Start isIncluded. First operand 40 states. Second operand 40 states. [2018-11-23 12:10:16,157 INFO L87 Difference]: Start difference. First operand 40 states. Second operand 40 states. [2018-11-23 12:10:16,158 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:16,159 INFO L93 Difference]: Finished difference Result 40 states and 41 transitions. [2018-11-23 12:10:16,159 INFO L276 IsEmpty]: Start isEmpty. Operand 40 states and 41 transitions. [2018-11-23 12:10:16,159 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:16,159 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:16,159 INFO L74 IsIncluded]: Start isIncluded. First operand 40 states. Second operand 40 states. [2018-11-23 12:10:16,159 INFO L87 Difference]: Start difference. First operand 40 states. Second operand 40 states. [2018-11-23 12:10:16,160 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:16,160 INFO L93 Difference]: Finished difference Result 40 states and 41 transitions. [2018-11-23 12:10:16,160 INFO L276 IsEmpty]: Start isEmpty. Operand 40 states and 41 transitions. [2018-11-23 12:10:16,160 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:16,160 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:16,161 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:16,161 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:16,161 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 40 states. [2018-11-23 12:10:16,161 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 40 states to 40 states and 41 transitions. [2018-11-23 12:10:16,161 INFO L78 Accepts]: Start accepts. Automaton has 40 states and 41 transitions. Word has length 34 [2018-11-23 12:10:16,161 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:16,162 INFO L480 AbstractCegarLoop]: Abstraction has 40 states and 41 transitions. [2018-11-23 12:10:16,162 INFO L481 AbstractCegarLoop]: Interpolant automaton has 25 states. [2018-11-23 12:10:16,162 INFO L276 IsEmpty]: Start isEmpty. Operand 40 states and 41 transitions. [2018-11-23 12:10:16,162 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 36 [2018-11-23 12:10:16,162 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:16,162 INFO L402 BasicCegarLoop]: trace histogram [22, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:16,162 INFO L423 AbstractCegarLoop]: === Iteration 24 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:16,163 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:16,163 INFO L82 PathProgramCache]: Analyzing trace with hash 841008690, now seen corresponding path program 22 times [2018-11-23 12:10:16,163 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:16,163 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:16,163 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:16,163 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:16,164 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:16,181 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:16,514 INFO L256 TraceCheckUtils]: 0: Hoare triple {5715#true} call ULTIMATE.init(); {5715#true} is VALID [2018-11-23 12:10:16,514 INFO L273 TraceCheckUtils]: 1: Hoare triple {5715#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {5715#true} is VALID [2018-11-23 12:10:16,515 INFO L273 TraceCheckUtils]: 2: Hoare triple {5715#true} assume true; {5715#true} is VALID [2018-11-23 12:10:16,515 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {5715#true} {5715#true} #48#return; {5715#true} is VALID [2018-11-23 12:10:16,515 INFO L256 TraceCheckUtils]: 4: Hoare triple {5715#true} call #t~ret6 := main(); {5715#true} is VALID [2018-11-23 12:10:16,516 INFO L273 TraceCheckUtils]: 5: Hoare triple {5715#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {5717#(= main_~i~0 0)} is VALID [2018-11-23 12:10:16,517 INFO L273 TraceCheckUtils]: 6: Hoare triple {5717#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5718#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:16,518 INFO L273 TraceCheckUtils]: 7: Hoare triple {5718#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5719#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:16,519 INFO L273 TraceCheckUtils]: 8: Hoare triple {5719#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5720#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:16,520 INFO L273 TraceCheckUtils]: 9: Hoare triple {5720#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5721#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:16,521 INFO L273 TraceCheckUtils]: 10: Hoare triple {5721#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5722#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:16,522 INFO L273 TraceCheckUtils]: 11: Hoare triple {5722#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5723#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:16,523 INFO L273 TraceCheckUtils]: 12: Hoare triple {5723#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5724#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:16,524 INFO L273 TraceCheckUtils]: 13: Hoare triple {5724#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5725#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:16,525 INFO L273 TraceCheckUtils]: 14: Hoare triple {5725#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5726#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:16,527 INFO L273 TraceCheckUtils]: 15: Hoare triple {5726#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5727#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:16,528 INFO L273 TraceCheckUtils]: 16: Hoare triple {5727#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5728#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:16,529 INFO L273 TraceCheckUtils]: 17: Hoare triple {5728#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5729#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:16,530 INFO L273 TraceCheckUtils]: 18: Hoare triple {5729#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5730#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:16,531 INFO L273 TraceCheckUtils]: 19: Hoare triple {5730#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5731#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:16,532 INFO L273 TraceCheckUtils]: 20: Hoare triple {5731#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5732#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:16,533 INFO L273 TraceCheckUtils]: 21: Hoare triple {5732#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5733#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:16,534 INFO L273 TraceCheckUtils]: 22: Hoare triple {5733#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5734#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:16,535 INFO L273 TraceCheckUtils]: 23: Hoare triple {5734#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5735#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:16,536 INFO L273 TraceCheckUtils]: 24: Hoare triple {5735#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5736#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:16,537 INFO L273 TraceCheckUtils]: 25: Hoare triple {5736#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5737#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:16,538 INFO L273 TraceCheckUtils]: 26: Hoare triple {5737#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5738#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:16,539 INFO L273 TraceCheckUtils]: 27: Hoare triple {5738#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5739#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:16,540 INFO L273 TraceCheckUtils]: 28: Hoare triple {5739#(<= main_~i~0 22)} assume !(~i~0 < 100000); {5716#false} is VALID [2018-11-23 12:10:16,540 INFO L273 TraceCheckUtils]: 29: Hoare triple {5716#false} havoc ~x~0;~x~0 := 0; {5716#false} is VALID [2018-11-23 12:10:16,541 INFO L273 TraceCheckUtils]: 30: Hoare triple {5716#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {5716#false} is VALID [2018-11-23 12:10:16,541 INFO L256 TraceCheckUtils]: 31: Hoare triple {5716#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {5716#false} is VALID [2018-11-23 12:10:16,541 INFO L273 TraceCheckUtils]: 32: Hoare triple {5716#false} ~cond := #in~cond; {5716#false} is VALID [2018-11-23 12:10:16,541 INFO L273 TraceCheckUtils]: 33: Hoare triple {5716#false} assume 0 == ~cond; {5716#false} is VALID [2018-11-23 12:10:16,541 INFO L273 TraceCheckUtils]: 34: Hoare triple {5716#false} assume !false; {5716#false} is VALID [2018-11-23 12:10:16,543 INFO L134 CoverageAnalysis]: Checked inductivity of 253 backedges. 0 proven. 253 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:16,543 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:16,543 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 23 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 23 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:16,552 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:10:16,601 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:10:16,601 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:16,615 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:16,616 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:16,780 INFO L256 TraceCheckUtils]: 0: Hoare triple {5715#true} call ULTIMATE.init(); {5715#true} is VALID [2018-11-23 12:10:16,780 INFO L273 TraceCheckUtils]: 1: Hoare triple {5715#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {5715#true} is VALID [2018-11-23 12:10:16,780 INFO L273 TraceCheckUtils]: 2: Hoare triple {5715#true} assume true; {5715#true} is VALID [2018-11-23 12:10:16,781 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {5715#true} {5715#true} #48#return; {5715#true} is VALID [2018-11-23 12:10:16,781 INFO L256 TraceCheckUtils]: 4: Hoare triple {5715#true} call #t~ret6 := main(); {5715#true} is VALID [2018-11-23 12:10:16,782 INFO L273 TraceCheckUtils]: 5: Hoare triple {5715#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {5758#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:16,783 INFO L273 TraceCheckUtils]: 6: Hoare triple {5758#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5718#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:16,783 INFO L273 TraceCheckUtils]: 7: Hoare triple {5718#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5719#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:16,784 INFO L273 TraceCheckUtils]: 8: Hoare triple {5719#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5720#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:16,785 INFO L273 TraceCheckUtils]: 9: Hoare triple {5720#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5721#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:16,786 INFO L273 TraceCheckUtils]: 10: Hoare triple {5721#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5722#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:16,787 INFO L273 TraceCheckUtils]: 11: Hoare triple {5722#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5723#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:16,788 INFO L273 TraceCheckUtils]: 12: Hoare triple {5723#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5724#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:16,789 INFO L273 TraceCheckUtils]: 13: Hoare triple {5724#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5725#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:16,790 INFO L273 TraceCheckUtils]: 14: Hoare triple {5725#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5726#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:16,792 INFO L273 TraceCheckUtils]: 15: Hoare triple {5726#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5727#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:16,793 INFO L273 TraceCheckUtils]: 16: Hoare triple {5727#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5728#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:16,794 INFO L273 TraceCheckUtils]: 17: Hoare triple {5728#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5729#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:16,795 INFO L273 TraceCheckUtils]: 18: Hoare triple {5729#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5730#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:16,796 INFO L273 TraceCheckUtils]: 19: Hoare triple {5730#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5731#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:16,797 INFO L273 TraceCheckUtils]: 20: Hoare triple {5731#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5732#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:16,798 INFO L273 TraceCheckUtils]: 21: Hoare triple {5732#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5733#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:16,799 INFO L273 TraceCheckUtils]: 22: Hoare triple {5733#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5734#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:16,800 INFO L273 TraceCheckUtils]: 23: Hoare triple {5734#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5735#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:16,801 INFO L273 TraceCheckUtils]: 24: Hoare triple {5735#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5736#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:16,802 INFO L273 TraceCheckUtils]: 25: Hoare triple {5736#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5737#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:16,803 INFO L273 TraceCheckUtils]: 26: Hoare triple {5737#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5738#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:16,805 INFO L273 TraceCheckUtils]: 27: Hoare triple {5738#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {5739#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:16,805 INFO L273 TraceCheckUtils]: 28: Hoare triple {5739#(<= main_~i~0 22)} assume !(~i~0 < 100000); {5716#false} is VALID [2018-11-23 12:10:16,805 INFO L273 TraceCheckUtils]: 29: Hoare triple {5716#false} havoc ~x~0;~x~0 := 0; {5716#false} is VALID [2018-11-23 12:10:16,806 INFO L273 TraceCheckUtils]: 30: Hoare triple {5716#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {5716#false} is VALID [2018-11-23 12:10:16,806 INFO L256 TraceCheckUtils]: 31: Hoare triple {5716#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {5716#false} is VALID [2018-11-23 12:10:16,806 INFO L273 TraceCheckUtils]: 32: Hoare triple {5716#false} ~cond := #in~cond; {5716#false} is VALID [2018-11-23 12:10:16,806 INFO L273 TraceCheckUtils]: 33: Hoare triple {5716#false} assume 0 == ~cond; {5716#false} is VALID [2018-11-23 12:10:16,807 INFO L273 TraceCheckUtils]: 34: Hoare triple {5716#false} assume !false; {5716#false} is VALID [2018-11-23 12:10:16,808 INFO L134 CoverageAnalysis]: Checked inductivity of 253 backedges. 0 proven. 253 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:16,826 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:16,827 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [25, 25] total 26 [2018-11-23 12:10:16,827 INFO L78 Accepts]: Start accepts. Automaton has 26 states. Word has length 35 [2018-11-23 12:10:16,827 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:16,827 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 26 states. [2018-11-23 12:10:16,855 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:10:16,855 INFO L459 AbstractCegarLoop]: Interpolant automaton has 26 states [2018-11-23 12:10:16,856 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 26 interpolants. [2018-11-23 12:10:16,856 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=325, Invalid=325, Unknown=0, NotChecked=0, Total=650 [2018-11-23 12:10:16,857 INFO L87 Difference]: Start difference. First operand 40 states and 41 transitions. Second operand 26 states. [2018-11-23 12:10:17,093 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:17,093 INFO L93 Difference]: Finished difference Result 52 states and 54 transitions. [2018-11-23 12:10:17,093 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 25 states. [2018-11-23 12:10:17,093 INFO L78 Accepts]: Start accepts. Automaton has 26 states. Word has length 35 [2018-11-23 12:10:17,094 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:17,094 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 26 states. [2018-11-23 12:10:17,095 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 25 states to 25 states and 54 transitions. [2018-11-23 12:10:17,095 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 26 states. [2018-11-23 12:10:17,096 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 25 states to 25 states and 54 transitions. [2018-11-23 12:10:17,096 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 25 states and 54 transitions. [2018-11-23 12:10:17,528 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 54 edges. 54 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:17,530 INFO L225 Difference]: With dead ends: 52 [2018-11-23 12:10:17,530 INFO L226 Difference]: Without dead ends: 41 [2018-11-23 12:10:17,531 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 59 GetRequests, 35 SyntacticMatches, 0 SemanticMatches, 24 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 42 ImplicationChecksByTransitivity, 0.2s TimeCoverageRelationStatistics Valid=325, Invalid=325, Unknown=0, NotChecked=0, Total=650 [2018-11-23 12:10:17,531 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 41 states. [2018-11-23 12:10:17,549 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 41 to 41. [2018-11-23 12:10:17,549 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:17,549 INFO L82 GeneralOperation]: Start isEquivalent. First operand 41 states. Second operand 41 states. [2018-11-23 12:10:17,549 INFO L74 IsIncluded]: Start isIncluded. First operand 41 states. Second operand 41 states. [2018-11-23 12:10:17,549 INFO L87 Difference]: Start difference. First operand 41 states. Second operand 41 states. [2018-11-23 12:10:17,550 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:17,550 INFO L93 Difference]: Finished difference Result 41 states and 42 transitions. [2018-11-23 12:10:17,550 INFO L276 IsEmpty]: Start isEmpty. Operand 41 states and 42 transitions. [2018-11-23 12:10:17,550 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:17,551 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:17,551 INFO L74 IsIncluded]: Start isIncluded. First operand 41 states. Second operand 41 states. [2018-11-23 12:10:17,551 INFO L87 Difference]: Start difference. First operand 41 states. Second operand 41 states. [2018-11-23 12:10:17,552 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:17,552 INFO L93 Difference]: Finished difference Result 41 states and 42 transitions. [2018-11-23 12:10:17,552 INFO L276 IsEmpty]: Start isEmpty. Operand 41 states and 42 transitions. [2018-11-23 12:10:17,552 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:17,552 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:17,552 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:17,553 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:17,553 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 41 states. [2018-11-23 12:10:17,553 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 41 states to 41 states and 42 transitions. [2018-11-23 12:10:17,554 INFO L78 Accepts]: Start accepts. Automaton has 41 states and 42 transitions. Word has length 35 [2018-11-23 12:10:17,554 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:17,554 INFO L480 AbstractCegarLoop]: Abstraction has 41 states and 42 transitions. [2018-11-23 12:10:17,554 INFO L481 AbstractCegarLoop]: Interpolant automaton has 26 states. [2018-11-23 12:10:17,554 INFO L276 IsEmpty]: Start isEmpty. Operand 41 states and 42 transitions. [2018-11-23 12:10:17,555 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 37 [2018-11-23 12:10:17,555 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:17,555 INFO L402 BasicCegarLoop]: trace histogram [23, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:17,555 INFO L423 AbstractCegarLoop]: === Iteration 25 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:17,555 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:17,555 INFO L82 PathProgramCache]: Analyzing trace with hash -1789613074, now seen corresponding path program 23 times [2018-11-23 12:10:17,555 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:17,556 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:17,556 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:17,556 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:17,556 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:17,575 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:18,022 INFO L256 TraceCheckUtils]: 0: Hoare triple {6085#true} call ULTIMATE.init(); {6085#true} is VALID [2018-11-23 12:10:18,022 INFO L273 TraceCheckUtils]: 1: Hoare triple {6085#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {6085#true} is VALID [2018-11-23 12:10:18,022 INFO L273 TraceCheckUtils]: 2: Hoare triple {6085#true} assume true; {6085#true} is VALID [2018-11-23 12:10:18,023 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {6085#true} {6085#true} #48#return; {6085#true} is VALID [2018-11-23 12:10:18,023 INFO L256 TraceCheckUtils]: 4: Hoare triple {6085#true} call #t~ret6 := main(); {6085#true} is VALID [2018-11-23 12:10:18,023 INFO L273 TraceCheckUtils]: 5: Hoare triple {6085#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {6087#(= main_~i~0 0)} is VALID [2018-11-23 12:10:18,025 INFO L273 TraceCheckUtils]: 6: Hoare triple {6087#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6088#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:18,026 INFO L273 TraceCheckUtils]: 7: Hoare triple {6088#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6089#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:18,027 INFO L273 TraceCheckUtils]: 8: Hoare triple {6089#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6090#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:18,028 INFO L273 TraceCheckUtils]: 9: Hoare triple {6090#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6091#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:18,029 INFO L273 TraceCheckUtils]: 10: Hoare triple {6091#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6092#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:18,030 INFO L273 TraceCheckUtils]: 11: Hoare triple {6092#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6093#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:18,031 INFO L273 TraceCheckUtils]: 12: Hoare triple {6093#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6094#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:18,032 INFO L273 TraceCheckUtils]: 13: Hoare triple {6094#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6095#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:18,033 INFO L273 TraceCheckUtils]: 14: Hoare triple {6095#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6096#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:18,034 INFO L273 TraceCheckUtils]: 15: Hoare triple {6096#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6097#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:18,035 INFO L273 TraceCheckUtils]: 16: Hoare triple {6097#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6098#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:18,037 INFO L273 TraceCheckUtils]: 17: Hoare triple {6098#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6099#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:18,038 INFO L273 TraceCheckUtils]: 18: Hoare triple {6099#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6100#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:18,039 INFO L273 TraceCheckUtils]: 19: Hoare triple {6100#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6101#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:18,040 INFO L273 TraceCheckUtils]: 20: Hoare triple {6101#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6102#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:18,041 INFO L273 TraceCheckUtils]: 21: Hoare triple {6102#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6103#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:18,042 INFO L273 TraceCheckUtils]: 22: Hoare triple {6103#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6104#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:18,043 INFO L273 TraceCheckUtils]: 23: Hoare triple {6104#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6105#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:18,044 INFO L273 TraceCheckUtils]: 24: Hoare triple {6105#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6106#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:18,045 INFO L273 TraceCheckUtils]: 25: Hoare triple {6106#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6107#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:18,046 INFO L273 TraceCheckUtils]: 26: Hoare triple {6107#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6108#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:18,047 INFO L273 TraceCheckUtils]: 27: Hoare triple {6108#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6109#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:18,049 INFO L273 TraceCheckUtils]: 28: Hoare triple {6109#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6110#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:18,049 INFO L273 TraceCheckUtils]: 29: Hoare triple {6110#(<= main_~i~0 23)} assume !(~i~0 < 100000); {6086#false} is VALID [2018-11-23 12:10:18,049 INFO L273 TraceCheckUtils]: 30: Hoare triple {6086#false} havoc ~x~0;~x~0 := 0; {6086#false} is VALID [2018-11-23 12:10:18,050 INFO L273 TraceCheckUtils]: 31: Hoare triple {6086#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {6086#false} is VALID [2018-11-23 12:10:18,050 INFO L256 TraceCheckUtils]: 32: Hoare triple {6086#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {6086#false} is VALID [2018-11-23 12:10:18,050 INFO L273 TraceCheckUtils]: 33: Hoare triple {6086#false} ~cond := #in~cond; {6086#false} is VALID [2018-11-23 12:10:18,050 INFO L273 TraceCheckUtils]: 34: Hoare triple {6086#false} assume 0 == ~cond; {6086#false} is VALID [2018-11-23 12:10:18,051 INFO L273 TraceCheckUtils]: 35: Hoare triple {6086#false} assume !false; {6086#false} is VALID [2018-11-23 12:10:18,052 INFO L134 CoverageAnalysis]: Checked inductivity of 276 backedges. 0 proven. 276 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:18,053 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:18,053 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 24 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 24 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:18,062 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:10:19,685 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 13 check-sat command(s) [2018-11-23 12:10:19,686 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:19,703 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:19,704 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:19,852 INFO L256 TraceCheckUtils]: 0: Hoare triple {6085#true} call ULTIMATE.init(); {6085#true} is VALID [2018-11-23 12:10:19,852 INFO L273 TraceCheckUtils]: 1: Hoare triple {6085#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {6085#true} is VALID [2018-11-23 12:10:19,852 INFO L273 TraceCheckUtils]: 2: Hoare triple {6085#true} assume true; {6085#true} is VALID [2018-11-23 12:10:19,852 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {6085#true} {6085#true} #48#return; {6085#true} is VALID [2018-11-23 12:10:19,853 INFO L256 TraceCheckUtils]: 4: Hoare triple {6085#true} call #t~ret6 := main(); {6085#true} is VALID [2018-11-23 12:10:19,853 INFO L273 TraceCheckUtils]: 5: Hoare triple {6085#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {6129#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:19,854 INFO L273 TraceCheckUtils]: 6: Hoare triple {6129#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6088#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:19,855 INFO L273 TraceCheckUtils]: 7: Hoare triple {6088#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6089#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:19,855 INFO L273 TraceCheckUtils]: 8: Hoare triple {6089#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6090#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:19,856 INFO L273 TraceCheckUtils]: 9: Hoare triple {6090#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6091#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:19,857 INFO L273 TraceCheckUtils]: 10: Hoare triple {6091#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6092#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:19,858 INFO L273 TraceCheckUtils]: 11: Hoare triple {6092#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6093#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:19,860 INFO L273 TraceCheckUtils]: 12: Hoare triple {6093#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6094#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:19,861 INFO L273 TraceCheckUtils]: 13: Hoare triple {6094#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6095#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:19,862 INFO L273 TraceCheckUtils]: 14: Hoare triple {6095#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6096#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:19,863 INFO L273 TraceCheckUtils]: 15: Hoare triple {6096#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6097#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:19,864 INFO L273 TraceCheckUtils]: 16: Hoare triple {6097#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6098#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:19,865 INFO L273 TraceCheckUtils]: 17: Hoare triple {6098#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6099#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:19,866 INFO L273 TraceCheckUtils]: 18: Hoare triple {6099#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6100#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:19,867 INFO L273 TraceCheckUtils]: 19: Hoare triple {6100#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6101#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:19,868 INFO L273 TraceCheckUtils]: 20: Hoare triple {6101#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6102#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:19,869 INFO L273 TraceCheckUtils]: 21: Hoare triple {6102#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6103#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:19,870 INFO L273 TraceCheckUtils]: 22: Hoare triple {6103#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6104#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:19,871 INFO L273 TraceCheckUtils]: 23: Hoare triple {6104#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6105#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:19,872 INFO L273 TraceCheckUtils]: 24: Hoare triple {6105#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6106#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:19,873 INFO L273 TraceCheckUtils]: 25: Hoare triple {6106#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6107#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:19,874 INFO L273 TraceCheckUtils]: 26: Hoare triple {6107#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6108#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:19,875 INFO L273 TraceCheckUtils]: 27: Hoare triple {6108#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6109#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:19,876 INFO L273 TraceCheckUtils]: 28: Hoare triple {6109#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6110#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:19,876 INFO L273 TraceCheckUtils]: 29: Hoare triple {6110#(<= main_~i~0 23)} assume !(~i~0 < 100000); {6086#false} is VALID [2018-11-23 12:10:19,877 INFO L273 TraceCheckUtils]: 30: Hoare triple {6086#false} havoc ~x~0;~x~0 := 0; {6086#false} is VALID [2018-11-23 12:10:19,877 INFO L273 TraceCheckUtils]: 31: Hoare triple {6086#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {6086#false} is VALID [2018-11-23 12:10:19,877 INFO L256 TraceCheckUtils]: 32: Hoare triple {6086#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {6086#false} is VALID [2018-11-23 12:10:19,877 INFO L273 TraceCheckUtils]: 33: Hoare triple {6086#false} ~cond := #in~cond; {6086#false} is VALID [2018-11-23 12:10:19,877 INFO L273 TraceCheckUtils]: 34: Hoare triple {6086#false} assume 0 == ~cond; {6086#false} is VALID [2018-11-23 12:10:19,878 INFO L273 TraceCheckUtils]: 35: Hoare triple {6086#false} assume !false; {6086#false} is VALID [2018-11-23 12:10:19,879 INFO L134 CoverageAnalysis]: Checked inductivity of 276 backedges. 0 proven. 276 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:19,899 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:19,900 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [26, 26] total 27 [2018-11-23 12:10:19,900 INFO L78 Accepts]: Start accepts. Automaton has 27 states. Word has length 36 [2018-11-23 12:10:19,900 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:19,900 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 27 states. [2018-11-23 12:10:19,932 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:10:19,932 INFO L459 AbstractCegarLoop]: Interpolant automaton has 27 states [2018-11-23 12:10:19,933 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 27 interpolants. [2018-11-23 12:10:19,933 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=351, Invalid=351, Unknown=0, NotChecked=0, Total=702 [2018-11-23 12:10:19,934 INFO L87 Difference]: Start difference. First operand 41 states and 42 transitions. Second operand 27 states. [2018-11-23 12:10:20,290 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:20,290 INFO L93 Difference]: Finished difference Result 53 states and 55 transitions. [2018-11-23 12:10:20,291 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 26 states. [2018-11-23 12:10:20,291 INFO L78 Accepts]: Start accepts. Automaton has 27 states. Word has length 36 [2018-11-23 12:10:20,291 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:20,291 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 27 states. [2018-11-23 12:10:20,292 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 26 states to 26 states and 55 transitions. [2018-11-23 12:10:20,292 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 27 states. [2018-11-23 12:10:20,293 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 26 states to 26 states and 55 transitions. [2018-11-23 12:10:20,293 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 26 states and 55 transitions. [2018-11-23 12:10:20,334 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 55 edges. 55 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:20,335 INFO L225 Difference]: With dead ends: 53 [2018-11-23 12:10:20,336 INFO L226 Difference]: Without dead ends: 42 [2018-11-23 12:10:20,336 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 61 GetRequests, 36 SyntacticMatches, 0 SemanticMatches, 25 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 44 ImplicationChecksByTransitivity, 0.3s TimeCoverageRelationStatistics Valid=351, Invalid=351, Unknown=0, NotChecked=0, Total=702 [2018-11-23 12:10:20,337 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 42 states. [2018-11-23 12:10:20,405 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 42 to 42. [2018-11-23 12:10:20,405 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:20,406 INFO L82 GeneralOperation]: Start isEquivalent. First operand 42 states. Second operand 42 states. [2018-11-23 12:10:20,406 INFO L74 IsIncluded]: Start isIncluded. First operand 42 states. Second operand 42 states. [2018-11-23 12:10:20,406 INFO L87 Difference]: Start difference. First operand 42 states. Second operand 42 states. [2018-11-23 12:10:20,406 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:20,407 INFO L93 Difference]: Finished difference Result 42 states and 43 transitions. [2018-11-23 12:10:20,407 INFO L276 IsEmpty]: Start isEmpty. Operand 42 states and 43 transitions. [2018-11-23 12:10:20,407 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:20,407 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:20,407 INFO L74 IsIncluded]: Start isIncluded. First operand 42 states. Second operand 42 states. [2018-11-23 12:10:20,407 INFO L87 Difference]: Start difference. First operand 42 states. Second operand 42 states. [2018-11-23 12:10:20,408 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:20,408 INFO L93 Difference]: Finished difference Result 42 states and 43 transitions. [2018-11-23 12:10:20,408 INFO L276 IsEmpty]: Start isEmpty. Operand 42 states and 43 transitions. [2018-11-23 12:10:20,408 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:20,408 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:20,408 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:20,408 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:20,408 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 42 states. [2018-11-23 12:10:20,409 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 42 states to 42 states and 43 transitions. [2018-11-23 12:10:20,409 INFO L78 Accepts]: Start accepts. Automaton has 42 states and 43 transitions. Word has length 36 [2018-11-23 12:10:20,409 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:20,409 INFO L480 AbstractCegarLoop]: Abstraction has 42 states and 43 transitions. [2018-11-23 12:10:20,409 INFO L481 AbstractCegarLoop]: Interpolant automaton has 27 states. [2018-11-23 12:10:20,409 INFO L276 IsEmpty]: Start isEmpty. Operand 42 states and 43 transitions. [2018-11-23 12:10:20,410 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 38 [2018-11-23 12:10:20,410 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:20,410 INFO L402 BasicCegarLoop]: trace histogram [24, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:20,410 INFO L423 AbstractCegarLoop]: === Iteration 26 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:20,410 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:20,410 INFO L82 PathProgramCache]: Analyzing trace with hash -1734509134, now seen corresponding path program 24 times [2018-11-23 12:10:20,410 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:20,410 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:20,411 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:20,411 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:20,411 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:20,432 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:21,212 INFO L256 TraceCheckUtils]: 0: Hoare triple {6465#true} call ULTIMATE.init(); {6465#true} is VALID [2018-11-23 12:10:21,212 INFO L273 TraceCheckUtils]: 1: Hoare triple {6465#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {6465#true} is VALID [2018-11-23 12:10:21,212 INFO L273 TraceCheckUtils]: 2: Hoare triple {6465#true} assume true; {6465#true} is VALID [2018-11-23 12:10:21,213 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {6465#true} {6465#true} #48#return; {6465#true} is VALID [2018-11-23 12:10:21,213 INFO L256 TraceCheckUtils]: 4: Hoare triple {6465#true} call #t~ret6 := main(); {6465#true} is VALID [2018-11-23 12:10:21,213 INFO L273 TraceCheckUtils]: 5: Hoare triple {6465#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {6467#(= main_~i~0 0)} is VALID [2018-11-23 12:10:21,214 INFO L273 TraceCheckUtils]: 6: Hoare triple {6467#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6468#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:21,216 INFO L273 TraceCheckUtils]: 7: Hoare triple {6468#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6469#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:21,217 INFO L273 TraceCheckUtils]: 8: Hoare triple {6469#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6470#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:21,218 INFO L273 TraceCheckUtils]: 9: Hoare triple {6470#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6471#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:21,219 INFO L273 TraceCheckUtils]: 10: Hoare triple {6471#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6472#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:21,220 INFO L273 TraceCheckUtils]: 11: Hoare triple {6472#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6473#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:21,221 INFO L273 TraceCheckUtils]: 12: Hoare triple {6473#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6474#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:21,222 INFO L273 TraceCheckUtils]: 13: Hoare triple {6474#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6475#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:21,223 INFO L273 TraceCheckUtils]: 14: Hoare triple {6475#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6476#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:21,224 INFO L273 TraceCheckUtils]: 15: Hoare triple {6476#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6477#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:21,225 INFO L273 TraceCheckUtils]: 16: Hoare triple {6477#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6478#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:21,227 INFO L273 TraceCheckUtils]: 17: Hoare triple {6478#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6479#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:21,228 INFO L273 TraceCheckUtils]: 18: Hoare triple {6479#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6480#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:21,229 INFO L273 TraceCheckUtils]: 19: Hoare triple {6480#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6481#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:21,230 INFO L273 TraceCheckUtils]: 20: Hoare triple {6481#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6482#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:21,231 INFO L273 TraceCheckUtils]: 21: Hoare triple {6482#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6483#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:21,232 INFO L273 TraceCheckUtils]: 22: Hoare triple {6483#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6484#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:21,233 INFO L273 TraceCheckUtils]: 23: Hoare triple {6484#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6485#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:21,234 INFO L273 TraceCheckUtils]: 24: Hoare triple {6485#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6486#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:21,235 INFO L273 TraceCheckUtils]: 25: Hoare triple {6486#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6487#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:21,236 INFO L273 TraceCheckUtils]: 26: Hoare triple {6487#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6488#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:21,237 INFO L273 TraceCheckUtils]: 27: Hoare triple {6488#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6489#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:21,238 INFO L273 TraceCheckUtils]: 28: Hoare triple {6489#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6490#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:21,239 INFO L273 TraceCheckUtils]: 29: Hoare triple {6490#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6491#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:21,240 INFO L273 TraceCheckUtils]: 30: Hoare triple {6491#(<= main_~i~0 24)} assume !(~i~0 < 100000); {6466#false} is VALID [2018-11-23 12:10:21,240 INFO L273 TraceCheckUtils]: 31: Hoare triple {6466#false} havoc ~x~0;~x~0 := 0; {6466#false} is VALID [2018-11-23 12:10:21,241 INFO L273 TraceCheckUtils]: 32: Hoare triple {6466#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {6466#false} is VALID [2018-11-23 12:10:21,241 INFO L256 TraceCheckUtils]: 33: Hoare triple {6466#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {6466#false} is VALID [2018-11-23 12:10:21,241 INFO L273 TraceCheckUtils]: 34: Hoare triple {6466#false} ~cond := #in~cond; {6466#false} is VALID [2018-11-23 12:10:21,241 INFO L273 TraceCheckUtils]: 35: Hoare triple {6466#false} assume 0 == ~cond; {6466#false} is VALID [2018-11-23 12:10:21,241 INFO L273 TraceCheckUtils]: 36: Hoare triple {6466#false} assume !false; {6466#false} is VALID [2018-11-23 12:10:21,243 INFO L134 CoverageAnalysis]: Checked inductivity of 300 backedges. 0 proven. 300 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:21,243 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:21,243 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:21,253 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE [2018-11-23 12:10:24,198 INFO L249 tOrderPrioritization]: Assert order MIX_INSIDE_OUTSIDE issued 13 check-sat command(s) [2018-11-23 12:10:24,199 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:24,215 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:24,215 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:24,366 INFO L256 TraceCheckUtils]: 0: Hoare triple {6465#true} call ULTIMATE.init(); {6465#true} is VALID [2018-11-23 12:10:24,366 INFO L273 TraceCheckUtils]: 1: Hoare triple {6465#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {6465#true} is VALID [2018-11-23 12:10:24,366 INFO L273 TraceCheckUtils]: 2: Hoare triple {6465#true} assume true; {6465#true} is VALID [2018-11-23 12:10:24,366 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {6465#true} {6465#true} #48#return; {6465#true} is VALID [2018-11-23 12:10:24,367 INFO L256 TraceCheckUtils]: 4: Hoare triple {6465#true} call #t~ret6 := main(); {6465#true} is VALID [2018-11-23 12:10:24,367 INFO L273 TraceCheckUtils]: 5: Hoare triple {6465#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {6510#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:24,368 INFO L273 TraceCheckUtils]: 6: Hoare triple {6510#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6468#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:24,369 INFO L273 TraceCheckUtils]: 7: Hoare triple {6468#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6469#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:24,369 INFO L273 TraceCheckUtils]: 8: Hoare triple {6469#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6470#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:24,370 INFO L273 TraceCheckUtils]: 9: Hoare triple {6470#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6471#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:24,370 INFO L273 TraceCheckUtils]: 10: Hoare triple {6471#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6472#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:24,371 INFO L273 TraceCheckUtils]: 11: Hoare triple {6472#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6473#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:24,372 INFO L273 TraceCheckUtils]: 12: Hoare triple {6473#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6474#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:24,373 INFO L273 TraceCheckUtils]: 13: Hoare triple {6474#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6475#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:24,374 INFO L273 TraceCheckUtils]: 14: Hoare triple {6475#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6476#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:24,375 INFO L273 TraceCheckUtils]: 15: Hoare triple {6476#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6477#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:24,376 INFO L273 TraceCheckUtils]: 16: Hoare triple {6477#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6478#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:24,377 INFO L273 TraceCheckUtils]: 17: Hoare triple {6478#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6479#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:24,378 INFO L273 TraceCheckUtils]: 18: Hoare triple {6479#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6480#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:24,379 INFO L273 TraceCheckUtils]: 19: Hoare triple {6480#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6481#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:24,380 INFO L273 TraceCheckUtils]: 20: Hoare triple {6481#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6482#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:24,381 INFO L273 TraceCheckUtils]: 21: Hoare triple {6482#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6483#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:24,382 INFO L273 TraceCheckUtils]: 22: Hoare triple {6483#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6484#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:24,383 INFO L273 TraceCheckUtils]: 23: Hoare triple {6484#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6485#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:24,384 INFO L273 TraceCheckUtils]: 24: Hoare triple {6485#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6486#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:24,385 INFO L273 TraceCheckUtils]: 25: Hoare triple {6486#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6487#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:24,386 INFO L273 TraceCheckUtils]: 26: Hoare triple {6487#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6488#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:24,388 INFO L273 TraceCheckUtils]: 27: Hoare triple {6488#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6489#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:24,389 INFO L273 TraceCheckUtils]: 28: Hoare triple {6489#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6490#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:24,390 INFO L273 TraceCheckUtils]: 29: Hoare triple {6490#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6491#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:24,390 INFO L273 TraceCheckUtils]: 30: Hoare triple {6491#(<= main_~i~0 24)} assume !(~i~0 < 100000); {6466#false} is VALID [2018-11-23 12:10:24,390 INFO L273 TraceCheckUtils]: 31: Hoare triple {6466#false} havoc ~x~0;~x~0 := 0; {6466#false} is VALID [2018-11-23 12:10:24,391 INFO L273 TraceCheckUtils]: 32: Hoare triple {6466#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {6466#false} is VALID [2018-11-23 12:10:24,391 INFO L256 TraceCheckUtils]: 33: Hoare triple {6466#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {6466#false} is VALID [2018-11-23 12:10:24,391 INFO L273 TraceCheckUtils]: 34: Hoare triple {6466#false} ~cond := #in~cond; {6466#false} is VALID [2018-11-23 12:10:24,391 INFO L273 TraceCheckUtils]: 35: Hoare triple {6466#false} assume 0 == ~cond; {6466#false} is VALID [2018-11-23 12:10:24,391 INFO L273 TraceCheckUtils]: 36: Hoare triple {6466#false} assume !false; {6466#false} is VALID [2018-11-23 12:10:24,393 INFO L134 CoverageAnalysis]: Checked inductivity of 300 backedges. 0 proven. 300 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:24,413 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:24,413 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [27, 27] total 28 [2018-11-23 12:10:24,413 INFO L78 Accepts]: Start accepts. Automaton has 28 states. Word has length 37 [2018-11-23 12:10:24,414 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:24,414 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 28 states. [2018-11-23 12:10:24,442 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:10:24,443 INFO L459 AbstractCegarLoop]: Interpolant automaton has 28 states [2018-11-23 12:10:24,443 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 28 interpolants. [2018-11-23 12:10:24,444 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=378, Invalid=378, Unknown=0, NotChecked=0, Total=756 [2018-11-23 12:10:24,444 INFO L87 Difference]: Start difference. First operand 42 states and 43 transitions. Second operand 28 states. [2018-11-23 12:10:24,864 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:24,864 INFO L93 Difference]: Finished difference Result 54 states and 56 transitions. [2018-11-23 12:10:24,864 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 27 states. [2018-11-23 12:10:24,864 INFO L78 Accepts]: Start accepts. Automaton has 28 states. Word has length 37 [2018-11-23 12:10:24,865 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:24,865 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 28 states. [2018-11-23 12:10:24,866 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 27 states to 27 states and 56 transitions. [2018-11-23 12:10:24,866 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 28 states. [2018-11-23 12:10:24,867 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 27 states to 27 states and 56 transitions. [2018-11-23 12:10:24,867 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 27 states and 56 transitions. [2018-11-23 12:10:24,911 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 56 edges. 56 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:24,912 INFO L225 Difference]: With dead ends: 54 [2018-11-23 12:10:24,913 INFO L226 Difference]: Without dead ends: 43 [2018-11-23 12:10:24,913 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 63 GetRequests, 37 SyntacticMatches, 0 SemanticMatches, 26 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 46 ImplicationChecksByTransitivity, 0.6s TimeCoverageRelationStatistics Valid=378, Invalid=378, Unknown=0, NotChecked=0, Total=756 [2018-11-23 12:10:24,914 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 43 states. [2018-11-23 12:10:24,935 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 43 to 43. [2018-11-23 12:10:24,936 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:24,936 INFO L82 GeneralOperation]: Start isEquivalent. First operand 43 states. Second operand 43 states. [2018-11-23 12:10:24,936 INFO L74 IsIncluded]: Start isIncluded. First operand 43 states. Second operand 43 states. [2018-11-23 12:10:24,936 INFO L87 Difference]: Start difference. First operand 43 states. Second operand 43 states. [2018-11-23 12:10:24,937 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:24,938 INFO L93 Difference]: Finished difference Result 43 states and 44 transitions. [2018-11-23 12:10:24,938 INFO L276 IsEmpty]: Start isEmpty. Operand 43 states and 44 transitions. [2018-11-23 12:10:24,938 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:24,939 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:24,939 INFO L74 IsIncluded]: Start isIncluded. First operand 43 states. Second operand 43 states. [2018-11-23 12:10:24,939 INFO L87 Difference]: Start difference. First operand 43 states. Second operand 43 states. [2018-11-23 12:10:24,940 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:24,940 INFO L93 Difference]: Finished difference Result 43 states and 44 transitions. [2018-11-23 12:10:24,940 INFO L276 IsEmpty]: Start isEmpty. Operand 43 states and 44 transitions. [2018-11-23 12:10:24,940 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:24,940 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:24,940 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:24,940 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:24,940 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 43 states. [2018-11-23 12:10:24,941 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 43 states to 43 states and 44 transitions. [2018-11-23 12:10:24,941 INFO L78 Accepts]: Start accepts. Automaton has 43 states and 44 transitions. Word has length 37 [2018-11-23 12:10:24,941 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:24,941 INFO L480 AbstractCegarLoop]: Abstraction has 43 states and 44 transitions. [2018-11-23 12:10:24,941 INFO L481 AbstractCegarLoop]: Interpolant automaton has 28 states. [2018-11-23 12:10:24,941 INFO L276 IsEmpty]: Start isEmpty. Operand 43 states and 44 transitions. [2018-11-23 12:10:24,942 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 39 [2018-11-23 12:10:24,942 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:24,942 INFO L402 BasicCegarLoop]: trace histogram [25, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:24,942 INFO L423 AbstractCegarLoop]: === Iteration 27 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:24,942 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:24,942 INFO L82 PathProgramCache]: Analyzing trace with hash -26286994, now seen corresponding path program 25 times [2018-11-23 12:10:24,942 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:24,942 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:24,943 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:24,943 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:24,943 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:24,965 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:25,928 INFO L256 TraceCheckUtils]: 0: Hoare triple {6855#true} call ULTIMATE.init(); {6855#true} is VALID [2018-11-23 12:10:25,928 INFO L273 TraceCheckUtils]: 1: Hoare triple {6855#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {6855#true} is VALID [2018-11-23 12:10:25,928 INFO L273 TraceCheckUtils]: 2: Hoare triple {6855#true} assume true; {6855#true} is VALID [2018-11-23 12:10:25,928 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {6855#true} {6855#true} #48#return; {6855#true} is VALID [2018-11-23 12:10:25,928 INFO L256 TraceCheckUtils]: 4: Hoare triple {6855#true} call #t~ret6 := main(); {6855#true} is VALID [2018-11-23 12:10:25,929 INFO L273 TraceCheckUtils]: 5: Hoare triple {6855#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {6857#(= main_~i~0 0)} is VALID [2018-11-23 12:10:25,930 INFO L273 TraceCheckUtils]: 6: Hoare triple {6857#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6858#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:25,931 INFO L273 TraceCheckUtils]: 7: Hoare triple {6858#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6859#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:25,932 INFO L273 TraceCheckUtils]: 8: Hoare triple {6859#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6860#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:25,933 INFO L273 TraceCheckUtils]: 9: Hoare triple {6860#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6861#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:25,935 INFO L273 TraceCheckUtils]: 10: Hoare triple {6861#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6862#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:25,936 INFO L273 TraceCheckUtils]: 11: Hoare triple {6862#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6863#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:25,937 INFO L273 TraceCheckUtils]: 12: Hoare triple {6863#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6864#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:25,938 INFO L273 TraceCheckUtils]: 13: Hoare triple {6864#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6865#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:25,939 INFO L273 TraceCheckUtils]: 14: Hoare triple {6865#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6866#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:25,940 INFO L273 TraceCheckUtils]: 15: Hoare triple {6866#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6867#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:25,941 INFO L273 TraceCheckUtils]: 16: Hoare triple {6867#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6868#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:25,942 INFO L273 TraceCheckUtils]: 17: Hoare triple {6868#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6869#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:25,943 INFO L273 TraceCheckUtils]: 18: Hoare triple {6869#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6870#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:25,945 INFO L273 TraceCheckUtils]: 19: Hoare triple {6870#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6871#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:25,946 INFO L273 TraceCheckUtils]: 20: Hoare triple {6871#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6872#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:25,947 INFO L273 TraceCheckUtils]: 21: Hoare triple {6872#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6873#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:25,948 INFO L273 TraceCheckUtils]: 22: Hoare triple {6873#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6874#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:25,949 INFO L273 TraceCheckUtils]: 23: Hoare triple {6874#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6875#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:25,950 INFO L273 TraceCheckUtils]: 24: Hoare triple {6875#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6876#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:25,951 INFO L273 TraceCheckUtils]: 25: Hoare triple {6876#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6877#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:25,952 INFO L273 TraceCheckUtils]: 26: Hoare triple {6877#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6878#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:25,953 INFO L273 TraceCheckUtils]: 27: Hoare triple {6878#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6879#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:25,954 INFO L273 TraceCheckUtils]: 28: Hoare triple {6879#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6880#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:25,956 INFO L273 TraceCheckUtils]: 29: Hoare triple {6880#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6881#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:25,957 INFO L273 TraceCheckUtils]: 30: Hoare triple {6881#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6882#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:25,957 INFO L273 TraceCheckUtils]: 31: Hoare triple {6882#(<= main_~i~0 25)} assume !(~i~0 < 100000); {6856#false} is VALID [2018-11-23 12:10:25,958 INFO L273 TraceCheckUtils]: 32: Hoare triple {6856#false} havoc ~x~0;~x~0 := 0; {6856#false} is VALID [2018-11-23 12:10:25,958 INFO L273 TraceCheckUtils]: 33: Hoare triple {6856#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {6856#false} is VALID [2018-11-23 12:10:25,958 INFO L256 TraceCheckUtils]: 34: Hoare triple {6856#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {6856#false} is VALID [2018-11-23 12:10:25,958 INFO L273 TraceCheckUtils]: 35: Hoare triple {6856#false} ~cond := #in~cond; {6856#false} is VALID [2018-11-23 12:10:25,958 INFO L273 TraceCheckUtils]: 36: Hoare triple {6856#false} assume 0 == ~cond; {6856#false} is VALID [2018-11-23 12:10:25,959 INFO L273 TraceCheckUtils]: 37: Hoare triple {6856#false} assume !false; {6856#false} is VALID [2018-11-23 12:10:25,960 INFO L134 CoverageAnalysis]: Checked inductivity of 325 backedges. 0 proven. 325 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:25,960 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:25,961 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:25,970 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:10:26,001 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:26,014 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:26,015 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:26,192 INFO L256 TraceCheckUtils]: 0: Hoare triple {6855#true} call ULTIMATE.init(); {6855#true} is VALID [2018-11-23 12:10:26,193 INFO L273 TraceCheckUtils]: 1: Hoare triple {6855#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {6855#true} is VALID [2018-11-23 12:10:26,193 INFO L273 TraceCheckUtils]: 2: Hoare triple {6855#true} assume true; {6855#true} is VALID [2018-11-23 12:10:26,193 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {6855#true} {6855#true} #48#return; {6855#true} is VALID [2018-11-23 12:10:26,193 INFO L256 TraceCheckUtils]: 4: Hoare triple {6855#true} call #t~ret6 := main(); {6855#true} is VALID [2018-11-23 12:10:26,194 INFO L273 TraceCheckUtils]: 5: Hoare triple {6855#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {6901#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:26,195 INFO L273 TraceCheckUtils]: 6: Hoare triple {6901#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6858#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:26,196 INFO L273 TraceCheckUtils]: 7: Hoare triple {6858#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6859#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:26,196 INFO L273 TraceCheckUtils]: 8: Hoare triple {6859#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6860#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:26,197 INFO L273 TraceCheckUtils]: 9: Hoare triple {6860#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6861#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:26,199 INFO L273 TraceCheckUtils]: 10: Hoare triple {6861#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6862#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:26,200 INFO L273 TraceCheckUtils]: 11: Hoare triple {6862#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6863#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:26,201 INFO L273 TraceCheckUtils]: 12: Hoare triple {6863#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6864#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:26,202 INFO L273 TraceCheckUtils]: 13: Hoare triple {6864#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6865#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:26,203 INFO L273 TraceCheckUtils]: 14: Hoare triple {6865#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6866#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:26,204 INFO L273 TraceCheckUtils]: 15: Hoare triple {6866#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6867#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:26,205 INFO L273 TraceCheckUtils]: 16: Hoare triple {6867#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6868#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:26,206 INFO L273 TraceCheckUtils]: 17: Hoare triple {6868#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6869#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:26,207 INFO L273 TraceCheckUtils]: 18: Hoare triple {6869#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6870#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:26,208 INFO L273 TraceCheckUtils]: 19: Hoare triple {6870#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6871#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:26,209 INFO L273 TraceCheckUtils]: 20: Hoare triple {6871#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6872#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:26,210 INFO L273 TraceCheckUtils]: 21: Hoare triple {6872#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6873#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:26,211 INFO L273 TraceCheckUtils]: 22: Hoare triple {6873#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6874#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:26,212 INFO L273 TraceCheckUtils]: 23: Hoare triple {6874#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6875#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:26,214 INFO L273 TraceCheckUtils]: 24: Hoare triple {6875#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6876#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:26,215 INFO L273 TraceCheckUtils]: 25: Hoare triple {6876#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6877#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:26,216 INFO L273 TraceCheckUtils]: 26: Hoare triple {6877#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6878#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:26,217 INFO L273 TraceCheckUtils]: 27: Hoare triple {6878#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6879#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:26,218 INFO L273 TraceCheckUtils]: 28: Hoare triple {6879#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6880#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:26,219 INFO L273 TraceCheckUtils]: 29: Hoare triple {6880#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6881#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:26,220 INFO L273 TraceCheckUtils]: 30: Hoare triple {6881#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {6882#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:26,221 INFO L273 TraceCheckUtils]: 31: Hoare triple {6882#(<= main_~i~0 25)} assume !(~i~0 < 100000); {6856#false} is VALID [2018-11-23 12:10:26,221 INFO L273 TraceCheckUtils]: 32: Hoare triple {6856#false} havoc ~x~0;~x~0 := 0; {6856#false} is VALID [2018-11-23 12:10:26,221 INFO L273 TraceCheckUtils]: 33: Hoare triple {6856#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {6856#false} is VALID [2018-11-23 12:10:26,221 INFO L256 TraceCheckUtils]: 34: Hoare triple {6856#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {6856#false} is VALID [2018-11-23 12:10:26,222 INFO L273 TraceCheckUtils]: 35: Hoare triple {6856#false} ~cond := #in~cond; {6856#false} is VALID [2018-11-23 12:10:26,222 INFO L273 TraceCheckUtils]: 36: Hoare triple {6856#false} assume 0 == ~cond; {6856#false} is VALID [2018-11-23 12:10:26,222 INFO L273 TraceCheckUtils]: 37: Hoare triple {6856#false} assume !false; {6856#false} is VALID [2018-11-23 12:10:26,224 INFO L134 CoverageAnalysis]: Checked inductivity of 325 backedges. 0 proven. 325 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:26,242 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:26,243 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [28, 28] total 29 [2018-11-23 12:10:26,243 INFO L78 Accepts]: Start accepts. Automaton has 29 states. Word has length 38 [2018-11-23 12:10:26,243 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:26,243 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 29 states. [2018-11-23 12:10:26,274 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 40 edges. 40 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:26,274 INFO L459 AbstractCegarLoop]: Interpolant automaton has 29 states [2018-11-23 12:10:26,275 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 29 interpolants. [2018-11-23 12:10:26,275 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=406, Invalid=406, Unknown=0, NotChecked=0, Total=812 [2018-11-23 12:10:26,275 INFO L87 Difference]: Start difference. First operand 43 states and 44 transitions. Second operand 29 states. [2018-11-23 12:10:27,062 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:27,063 INFO L93 Difference]: Finished difference Result 55 states and 57 transitions. [2018-11-23 12:10:27,063 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 28 states. [2018-11-23 12:10:27,063 INFO L78 Accepts]: Start accepts. Automaton has 29 states. Word has length 38 [2018-11-23 12:10:27,063 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:27,063 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 29 states. [2018-11-23 12:10:27,064 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 28 states to 28 states and 57 transitions. [2018-11-23 12:10:27,065 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 29 states. [2018-11-23 12:10:27,065 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 28 states to 28 states and 57 transitions. [2018-11-23 12:10:27,065 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 28 states and 57 transitions. [2018-11-23 12:10:27,108 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:10:27,109 INFO L225 Difference]: With dead ends: 55 [2018-11-23 12:10:27,109 INFO L226 Difference]: Without dead ends: 44 [2018-11-23 12:10:27,110 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 65 GetRequests, 38 SyntacticMatches, 0 SemanticMatches, 27 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 48 ImplicationChecksByTransitivity, 0.7s TimeCoverageRelationStatistics Valid=406, Invalid=406, Unknown=0, NotChecked=0, Total=812 [2018-11-23 12:10:27,110 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 44 states. [2018-11-23 12:10:27,138 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 44 to 44. [2018-11-23 12:10:27,138 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:27,139 INFO L82 GeneralOperation]: Start isEquivalent. First operand 44 states. Second operand 44 states. [2018-11-23 12:10:27,139 INFO L74 IsIncluded]: Start isIncluded. First operand 44 states. Second operand 44 states. [2018-11-23 12:10:27,139 INFO L87 Difference]: Start difference. First operand 44 states. Second operand 44 states. [2018-11-23 12:10:27,140 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:27,140 INFO L93 Difference]: Finished difference Result 44 states and 45 transitions. [2018-11-23 12:10:27,140 INFO L276 IsEmpty]: Start isEmpty. Operand 44 states and 45 transitions. [2018-11-23 12:10:27,140 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:27,141 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:27,141 INFO L74 IsIncluded]: Start isIncluded. First operand 44 states. Second operand 44 states. [2018-11-23 12:10:27,141 INFO L87 Difference]: Start difference. First operand 44 states. Second operand 44 states. [2018-11-23 12:10:27,142 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:27,142 INFO L93 Difference]: Finished difference Result 44 states and 45 transitions. [2018-11-23 12:10:27,142 INFO L276 IsEmpty]: Start isEmpty. Operand 44 states and 45 transitions. [2018-11-23 12:10:27,142 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:27,142 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:27,142 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:27,142 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:27,142 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 44 states. [2018-11-23 12:10:27,143 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 44 states to 44 states and 45 transitions. [2018-11-23 12:10:27,143 INFO L78 Accepts]: Start accepts. Automaton has 44 states and 45 transitions. Word has length 38 [2018-11-23 12:10:27,143 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:27,143 INFO L480 AbstractCegarLoop]: Abstraction has 44 states and 45 transitions. [2018-11-23 12:10:27,143 INFO L481 AbstractCegarLoop]: Interpolant automaton has 29 states. [2018-11-23 12:10:27,144 INFO L276 IsEmpty]: Start isEmpty. Operand 44 states and 45 transitions. [2018-11-23 12:10:27,144 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 40 [2018-11-23 12:10:27,144 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:27,144 INFO L402 BasicCegarLoop]: trace histogram [26, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:27,144 INFO L423 AbstractCegarLoop]: === Iteration 28 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:27,145 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:27,145 INFO L82 PathProgramCache]: Analyzing trace with hash 1388991794, now seen corresponding path program 26 times [2018-11-23 12:10:27,145 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:27,145 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:27,146 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:27,146 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:10:27,146 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:27,169 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:28,507 INFO L256 TraceCheckUtils]: 0: Hoare triple {7255#true} call ULTIMATE.init(); {7255#true} is VALID [2018-11-23 12:10:28,507 INFO L273 TraceCheckUtils]: 1: Hoare triple {7255#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {7255#true} is VALID [2018-11-23 12:10:28,508 INFO L273 TraceCheckUtils]: 2: Hoare triple {7255#true} assume true; {7255#true} is VALID [2018-11-23 12:10:28,508 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {7255#true} {7255#true} #48#return; {7255#true} is VALID [2018-11-23 12:10:28,508 INFO L256 TraceCheckUtils]: 4: Hoare triple {7255#true} call #t~ret6 := main(); {7255#true} is VALID [2018-11-23 12:10:28,509 INFO L273 TraceCheckUtils]: 5: Hoare triple {7255#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {7257#(= main_~i~0 0)} is VALID [2018-11-23 12:10:28,510 INFO L273 TraceCheckUtils]: 6: Hoare triple {7257#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7258#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:28,511 INFO L273 TraceCheckUtils]: 7: Hoare triple {7258#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7259#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:28,512 INFO L273 TraceCheckUtils]: 8: Hoare triple {7259#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7260#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:28,513 INFO L273 TraceCheckUtils]: 9: Hoare triple {7260#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7261#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:28,514 INFO L273 TraceCheckUtils]: 10: Hoare triple {7261#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7262#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:28,515 INFO L273 TraceCheckUtils]: 11: Hoare triple {7262#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7263#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:28,516 INFO L273 TraceCheckUtils]: 12: Hoare triple {7263#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7264#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:28,517 INFO L273 TraceCheckUtils]: 13: Hoare triple {7264#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7265#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:28,518 INFO L273 TraceCheckUtils]: 14: Hoare triple {7265#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7266#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:28,519 INFO L273 TraceCheckUtils]: 15: Hoare triple {7266#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7267#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:28,537 INFO L273 TraceCheckUtils]: 16: Hoare triple {7267#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7268#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:28,540 INFO L273 TraceCheckUtils]: 17: Hoare triple {7268#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7269#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:28,541 INFO L273 TraceCheckUtils]: 18: Hoare triple {7269#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7270#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:28,542 INFO L273 TraceCheckUtils]: 19: Hoare triple {7270#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7271#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:28,543 INFO L273 TraceCheckUtils]: 20: Hoare triple {7271#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7272#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:28,543 INFO L273 TraceCheckUtils]: 21: Hoare triple {7272#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7273#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:28,544 INFO L273 TraceCheckUtils]: 22: Hoare triple {7273#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7274#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:28,544 INFO L273 TraceCheckUtils]: 23: Hoare triple {7274#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7275#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:28,545 INFO L273 TraceCheckUtils]: 24: Hoare triple {7275#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7276#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:28,547 INFO L273 TraceCheckUtils]: 25: Hoare triple {7276#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7277#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:28,548 INFO L273 TraceCheckUtils]: 26: Hoare triple {7277#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7278#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:28,549 INFO L273 TraceCheckUtils]: 27: Hoare triple {7278#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7279#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:28,550 INFO L273 TraceCheckUtils]: 28: Hoare triple {7279#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7280#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:28,551 INFO L273 TraceCheckUtils]: 29: Hoare triple {7280#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7281#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:28,552 INFO L273 TraceCheckUtils]: 30: Hoare triple {7281#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7282#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:28,553 INFO L273 TraceCheckUtils]: 31: Hoare triple {7282#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7283#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:28,554 INFO L273 TraceCheckUtils]: 32: Hoare triple {7283#(<= main_~i~0 26)} assume !(~i~0 < 100000); {7256#false} is VALID [2018-11-23 12:10:28,554 INFO L273 TraceCheckUtils]: 33: Hoare triple {7256#false} havoc ~x~0;~x~0 := 0; {7256#false} is VALID [2018-11-23 12:10:28,554 INFO L273 TraceCheckUtils]: 34: Hoare triple {7256#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {7256#false} is VALID [2018-11-23 12:10:28,555 INFO L256 TraceCheckUtils]: 35: Hoare triple {7256#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {7256#false} is VALID [2018-11-23 12:10:28,555 INFO L273 TraceCheckUtils]: 36: Hoare triple {7256#false} ~cond := #in~cond; {7256#false} is VALID [2018-11-23 12:10:28,555 INFO L273 TraceCheckUtils]: 37: Hoare triple {7256#false} assume 0 == ~cond; {7256#false} is VALID [2018-11-23 12:10:28,555 INFO L273 TraceCheckUtils]: 38: Hoare triple {7256#false} assume !false; {7256#false} is VALID [2018-11-23 12:10:28,557 INFO L134 CoverageAnalysis]: Checked inductivity of 351 backedges. 0 proven. 351 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:28,557 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:28,557 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:28,566 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:10:28,603 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:10:28,603 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:28,616 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:28,617 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:28,770 INFO L256 TraceCheckUtils]: 0: Hoare triple {7255#true} call ULTIMATE.init(); {7255#true} is VALID [2018-11-23 12:10:28,771 INFO L273 TraceCheckUtils]: 1: Hoare triple {7255#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {7255#true} is VALID [2018-11-23 12:10:28,771 INFO L273 TraceCheckUtils]: 2: Hoare triple {7255#true} assume true; {7255#true} is VALID [2018-11-23 12:10:28,771 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {7255#true} {7255#true} #48#return; {7255#true} is VALID [2018-11-23 12:10:28,771 INFO L256 TraceCheckUtils]: 4: Hoare triple {7255#true} call #t~ret6 := main(); {7255#true} is VALID [2018-11-23 12:10:28,772 INFO L273 TraceCheckUtils]: 5: Hoare triple {7255#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {7302#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:28,773 INFO L273 TraceCheckUtils]: 6: Hoare triple {7302#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7258#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:28,774 INFO L273 TraceCheckUtils]: 7: Hoare triple {7258#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7259#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:28,774 INFO L273 TraceCheckUtils]: 8: Hoare triple {7259#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7260#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:28,775 INFO L273 TraceCheckUtils]: 9: Hoare triple {7260#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7261#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:28,776 INFO L273 TraceCheckUtils]: 10: Hoare triple {7261#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7262#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:28,778 INFO L273 TraceCheckUtils]: 11: Hoare triple {7262#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7263#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:28,779 INFO L273 TraceCheckUtils]: 12: Hoare triple {7263#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7264#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:28,780 INFO L273 TraceCheckUtils]: 13: Hoare triple {7264#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7265#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:28,781 INFO L273 TraceCheckUtils]: 14: Hoare triple {7265#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7266#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:28,782 INFO L273 TraceCheckUtils]: 15: Hoare triple {7266#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7267#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:28,783 INFO L273 TraceCheckUtils]: 16: Hoare triple {7267#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7268#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:28,784 INFO L273 TraceCheckUtils]: 17: Hoare triple {7268#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7269#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:28,785 INFO L273 TraceCheckUtils]: 18: Hoare triple {7269#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7270#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:28,786 INFO L273 TraceCheckUtils]: 19: Hoare triple {7270#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7271#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:28,787 INFO L273 TraceCheckUtils]: 20: Hoare triple {7271#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7272#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:28,788 INFO L273 TraceCheckUtils]: 21: Hoare triple {7272#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7273#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:28,789 INFO L273 TraceCheckUtils]: 22: Hoare triple {7273#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7274#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:28,790 INFO L273 TraceCheckUtils]: 23: Hoare triple {7274#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7275#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:28,791 INFO L273 TraceCheckUtils]: 24: Hoare triple {7275#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7276#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:28,792 INFO L273 TraceCheckUtils]: 25: Hoare triple {7276#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7277#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:28,793 INFO L273 TraceCheckUtils]: 26: Hoare triple {7277#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7278#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:28,795 INFO L273 TraceCheckUtils]: 27: Hoare triple {7278#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7279#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:28,796 INFO L273 TraceCheckUtils]: 28: Hoare triple {7279#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7280#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:28,797 INFO L273 TraceCheckUtils]: 29: Hoare triple {7280#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7281#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:28,798 INFO L273 TraceCheckUtils]: 30: Hoare triple {7281#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7282#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:28,799 INFO L273 TraceCheckUtils]: 31: Hoare triple {7282#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7283#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:28,800 INFO L273 TraceCheckUtils]: 32: Hoare triple {7283#(<= main_~i~0 26)} assume !(~i~0 < 100000); {7256#false} is VALID [2018-11-23 12:10:28,800 INFO L273 TraceCheckUtils]: 33: Hoare triple {7256#false} havoc ~x~0;~x~0 := 0; {7256#false} is VALID [2018-11-23 12:10:28,800 INFO L273 TraceCheckUtils]: 34: Hoare triple {7256#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {7256#false} is VALID [2018-11-23 12:10:28,800 INFO L256 TraceCheckUtils]: 35: Hoare triple {7256#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {7256#false} is VALID [2018-11-23 12:10:28,800 INFO L273 TraceCheckUtils]: 36: Hoare triple {7256#false} ~cond := #in~cond; {7256#false} is VALID [2018-11-23 12:10:28,801 INFO L273 TraceCheckUtils]: 37: Hoare triple {7256#false} assume 0 == ~cond; {7256#false} is VALID [2018-11-23 12:10:28,801 INFO L273 TraceCheckUtils]: 38: Hoare triple {7256#false} assume !false; {7256#false} is VALID [2018-11-23 12:10:28,803 INFO L134 CoverageAnalysis]: Checked inductivity of 351 backedges. 0 proven. 351 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:28,821 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:28,821 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [29, 29] total 30 [2018-11-23 12:10:28,821 INFO L78 Accepts]: Start accepts. Automaton has 30 states. Word has length 39 [2018-11-23 12:10:28,822 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:28,822 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 30 states. [2018-11-23 12:10:28,863 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 41 edges. 41 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:28,864 INFO L459 AbstractCegarLoop]: Interpolant automaton has 30 states [2018-11-23 12:10:28,864 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 30 interpolants. [2018-11-23 12:10:28,864 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=435, Invalid=435, Unknown=0, NotChecked=0, Total=870 [2018-11-23 12:10:28,864 INFO L87 Difference]: Start difference. First operand 44 states and 45 transitions. Second operand 30 states. [2018-11-23 12:10:29,537 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:29,537 INFO L93 Difference]: Finished difference Result 56 states and 58 transitions. [2018-11-23 12:10:29,537 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 29 states. [2018-11-23 12:10:29,538 INFO L78 Accepts]: Start accepts. Automaton has 30 states. Word has length 39 [2018-11-23 12:10:29,538 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:29,538 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 30 states. [2018-11-23 12:10:29,539 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 29 states to 29 states and 58 transitions. [2018-11-23 12:10:29,539 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 30 states. [2018-11-23 12:10:29,540 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 29 states to 29 states and 58 transitions. [2018-11-23 12:10:29,540 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 29 states and 58 transitions. [2018-11-23 12:10:29,585 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 58 edges. 58 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:29,586 INFO L225 Difference]: With dead ends: 56 [2018-11-23 12:10:29,586 INFO L226 Difference]: Without dead ends: 45 [2018-11-23 12:10:29,587 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 67 GetRequests, 39 SyntacticMatches, 0 SemanticMatches, 28 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 50 ImplicationChecksByTransitivity, 1.1s TimeCoverageRelationStatistics Valid=435, Invalid=435, Unknown=0, NotChecked=0, Total=870 [2018-11-23 12:10:29,587 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 45 states. [2018-11-23 12:10:29,610 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 45 to 45. [2018-11-23 12:10:29,610 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:29,610 INFO L82 GeneralOperation]: Start isEquivalent. First operand 45 states. Second operand 45 states. [2018-11-23 12:10:29,610 INFO L74 IsIncluded]: Start isIncluded. First operand 45 states. Second operand 45 states. [2018-11-23 12:10:29,610 INFO L87 Difference]: Start difference. First operand 45 states. Second operand 45 states. [2018-11-23 12:10:29,612 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:29,612 INFO L93 Difference]: Finished difference Result 45 states and 46 transitions. [2018-11-23 12:10:29,612 INFO L276 IsEmpty]: Start isEmpty. Operand 45 states and 46 transitions. [2018-11-23 12:10:29,613 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:29,613 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:29,613 INFO L74 IsIncluded]: Start isIncluded. First operand 45 states. Second operand 45 states. [2018-11-23 12:10:29,613 INFO L87 Difference]: Start difference. First operand 45 states. Second operand 45 states. [2018-11-23 12:10:29,614 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:29,614 INFO L93 Difference]: Finished difference Result 45 states and 46 transitions. [2018-11-23 12:10:29,614 INFO L276 IsEmpty]: Start isEmpty. Operand 45 states and 46 transitions. [2018-11-23 12:10:29,614 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:29,615 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:29,615 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:29,615 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:29,615 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 45 states. [2018-11-23 12:10:29,616 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 45 states to 45 states and 46 transitions. [2018-11-23 12:10:29,616 INFO L78 Accepts]: Start accepts. Automaton has 45 states and 46 transitions. Word has length 39 [2018-11-23 12:10:29,616 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:29,616 INFO L480 AbstractCegarLoop]: Abstraction has 45 states and 46 transitions. [2018-11-23 12:10:29,616 INFO L481 AbstractCegarLoop]: Interpolant automaton has 30 states. [2018-11-23 12:10:29,616 INFO L276 IsEmpty]: Start isEmpty. Operand 45 states and 46 transitions. [2018-11-23 12:10:29,617 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 41 [2018-11-23 12:10:29,617 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:29,617 INFO L402 BasicCegarLoop]: trace histogram [27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:29,617 INFO L423 AbstractCegarLoop]: === Iteration 29 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:29,617 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:29,618 INFO L82 PathProgramCache]: Analyzing trace with hash -1982006034, now seen corresponding path program 27 times [2018-11-23 12:10:29,618 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:29,618 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:29,618 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:29,619 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:29,619 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:29,643 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:30,619 INFO L256 TraceCheckUtils]: 0: Hoare triple {7665#true} call ULTIMATE.init(); {7665#true} is VALID [2018-11-23 12:10:30,619 INFO L273 TraceCheckUtils]: 1: Hoare triple {7665#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {7665#true} is VALID [2018-11-23 12:10:30,620 INFO L273 TraceCheckUtils]: 2: Hoare triple {7665#true} assume true; {7665#true} is VALID [2018-11-23 12:10:30,620 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {7665#true} {7665#true} #48#return; {7665#true} is VALID [2018-11-23 12:10:30,620 INFO L256 TraceCheckUtils]: 4: Hoare triple {7665#true} call #t~ret6 := main(); {7665#true} is VALID [2018-11-23 12:10:30,622 INFO L273 TraceCheckUtils]: 5: Hoare triple {7665#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {7667#(= main_~i~0 0)} is VALID [2018-11-23 12:10:30,622 INFO L273 TraceCheckUtils]: 6: Hoare triple {7667#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7668#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:30,623 INFO L273 TraceCheckUtils]: 7: Hoare triple {7668#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7669#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:30,624 INFO L273 TraceCheckUtils]: 8: Hoare triple {7669#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7670#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:30,624 INFO L273 TraceCheckUtils]: 9: Hoare triple {7670#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7671#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:30,625 INFO L273 TraceCheckUtils]: 10: Hoare triple {7671#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7672#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:30,626 INFO L273 TraceCheckUtils]: 11: Hoare triple {7672#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7673#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:30,627 INFO L273 TraceCheckUtils]: 12: Hoare triple {7673#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7674#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:30,628 INFO L273 TraceCheckUtils]: 13: Hoare triple {7674#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7675#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:30,629 INFO L273 TraceCheckUtils]: 14: Hoare triple {7675#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7676#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:30,630 INFO L273 TraceCheckUtils]: 15: Hoare triple {7676#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7677#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:30,631 INFO L273 TraceCheckUtils]: 16: Hoare triple {7677#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7678#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:30,632 INFO L273 TraceCheckUtils]: 17: Hoare triple {7678#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7679#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:30,633 INFO L273 TraceCheckUtils]: 18: Hoare triple {7679#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7680#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:30,634 INFO L273 TraceCheckUtils]: 19: Hoare triple {7680#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7681#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:30,635 INFO L273 TraceCheckUtils]: 20: Hoare triple {7681#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7682#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:30,636 INFO L273 TraceCheckUtils]: 21: Hoare triple {7682#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7683#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:30,637 INFO L273 TraceCheckUtils]: 22: Hoare triple {7683#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7684#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:30,638 INFO L273 TraceCheckUtils]: 23: Hoare triple {7684#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7685#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:30,640 INFO L273 TraceCheckUtils]: 24: Hoare triple {7685#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7686#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:30,641 INFO L273 TraceCheckUtils]: 25: Hoare triple {7686#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7687#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:30,642 INFO L273 TraceCheckUtils]: 26: Hoare triple {7687#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7688#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:30,643 INFO L273 TraceCheckUtils]: 27: Hoare triple {7688#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7689#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:30,644 INFO L273 TraceCheckUtils]: 28: Hoare triple {7689#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7690#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:30,645 INFO L273 TraceCheckUtils]: 29: Hoare triple {7690#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7691#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:30,646 INFO L273 TraceCheckUtils]: 30: Hoare triple {7691#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7692#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:30,647 INFO L273 TraceCheckUtils]: 31: Hoare triple {7692#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7693#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:30,648 INFO L273 TraceCheckUtils]: 32: Hoare triple {7693#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7694#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:30,649 INFO L273 TraceCheckUtils]: 33: Hoare triple {7694#(<= main_~i~0 27)} assume !(~i~0 < 100000); {7666#false} is VALID [2018-11-23 12:10:30,649 INFO L273 TraceCheckUtils]: 34: Hoare triple {7666#false} havoc ~x~0;~x~0 := 0; {7666#false} is VALID [2018-11-23 12:10:30,649 INFO L273 TraceCheckUtils]: 35: Hoare triple {7666#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {7666#false} is VALID [2018-11-23 12:10:30,649 INFO L256 TraceCheckUtils]: 36: Hoare triple {7666#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {7666#false} is VALID [2018-11-23 12:10:30,650 INFO L273 TraceCheckUtils]: 37: Hoare triple {7666#false} ~cond := #in~cond; {7666#false} is VALID [2018-11-23 12:10:30,650 INFO L273 TraceCheckUtils]: 38: Hoare triple {7666#false} assume 0 == ~cond; {7666#false} is VALID [2018-11-23 12:10:30,650 INFO L273 TraceCheckUtils]: 39: Hoare triple {7666#false} assume !false; {7666#false} is VALID [2018-11-23 12:10:30,652 INFO L134 CoverageAnalysis]: Checked inductivity of 378 backedges. 0 proven. 378 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:30,652 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:30,652 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:30,662 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:10:39,046 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 15 check-sat command(s) [2018-11-23 12:10:39,046 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:39,073 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:39,074 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:39,459 INFO L256 TraceCheckUtils]: 0: Hoare triple {7665#true} call ULTIMATE.init(); {7665#true} is VALID [2018-11-23 12:10:39,459 INFO L273 TraceCheckUtils]: 1: Hoare triple {7665#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {7665#true} is VALID [2018-11-23 12:10:39,459 INFO L273 TraceCheckUtils]: 2: Hoare triple {7665#true} assume true; {7665#true} is VALID [2018-11-23 12:10:39,459 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {7665#true} {7665#true} #48#return; {7665#true} is VALID [2018-11-23 12:10:39,459 INFO L256 TraceCheckUtils]: 4: Hoare triple {7665#true} call #t~ret6 := main(); {7665#true} is VALID [2018-11-23 12:10:39,460 INFO L273 TraceCheckUtils]: 5: Hoare triple {7665#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {7713#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:39,461 INFO L273 TraceCheckUtils]: 6: Hoare triple {7713#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7668#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:39,461 INFO L273 TraceCheckUtils]: 7: Hoare triple {7668#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7669#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:39,462 INFO L273 TraceCheckUtils]: 8: Hoare triple {7669#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7670#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:39,463 INFO L273 TraceCheckUtils]: 9: Hoare triple {7670#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7671#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:39,463 INFO L273 TraceCheckUtils]: 10: Hoare triple {7671#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7672#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:39,464 INFO L273 TraceCheckUtils]: 11: Hoare triple {7672#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7673#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:39,465 INFO L273 TraceCheckUtils]: 12: Hoare triple {7673#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7674#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:39,466 INFO L273 TraceCheckUtils]: 13: Hoare triple {7674#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7675#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:39,468 INFO L273 TraceCheckUtils]: 14: Hoare triple {7675#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7676#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:39,469 INFO L273 TraceCheckUtils]: 15: Hoare triple {7676#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7677#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:39,470 INFO L273 TraceCheckUtils]: 16: Hoare triple {7677#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7678#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:39,471 INFO L273 TraceCheckUtils]: 17: Hoare triple {7678#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7679#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:39,472 INFO L273 TraceCheckUtils]: 18: Hoare triple {7679#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7680#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:39,473 INFO L273 TraceCheckUtils]: 19: Hoare triple {7680#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7681#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:39,474 INFO L273 TraceCheckUtils]: 20: Hoare triple {7681#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7682#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:39,475 INFO L273 TraceCheckUtils]: 21: Hoare triple {7682#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7683#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:39,476 INFO L273 TraceCheckUtils]: 22: Hoare triple {7683#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7684#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:39,477 INFO L273 TraceCheckUtils]: 23: Hoare triple {7684#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7685#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:39,478 INFO L273 TraceCheckUtils]: 24: Hoare triple {7685#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7686#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:39,479 INFO L273 TraceCheckUtils]: 25: Hoare triple {7686#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7687#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:39,480 INFO L273 TraceCheckUtils]: 26: Hoare triple {7687#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7688#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:39,481 INFO L273 TraceCheckUtils]: 27: Hoare triple {7688#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7689#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:39,482 INFO L273 TraceCheckUtils]: 28: Hoare triple {7689#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7690#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:39,483 INFO L273 TraceCheckUtils]: 29: Hoare triple {7690#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7691#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:39,484 INFO L273 TraceCheckUtils]: 30: Hoare triple {7691#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7692#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:39,486 INFO L273 TraceCheckUtils]: 31: Hoare triple {7692#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7693#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:39,490 INFO L273 TraceCheckUtils]: 32: Hoare triple {7693#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {7694#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:39,490 INFO L273 TraceCheckUtils]: 33: Hoare triple {7694#(<= main_~i~0 27)} assume !(~i~0 < 100000); {7666#false} is VALID [2018-11-23 12:10:39,490 INFO L273 TraceCheckUtils]: 34: Hoare triple {7666#false} havoc ~x~0;~x~0 := 0; {7666#false} is VALID [2018-11-23 12:10:39,490 INFO L273 TraceCheckUtils]: 35: Hoare triple {7666#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {7666#false} is VALID [2018-11-23 12:10:39,491 INFO L256 TraceCheckUtils]: 36: Hoare triple {7666#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {7666#false} is VALID [2018-11-23 12:10:39,491 INFO L273 TraceCheckUtils]: 37: Hoare triple {7666#false} ~cond := #in~cond; {7666#false} is VALID [2018-11-23 12:10:39,491 INFO L273 TraceCheckUtils]: 38: Hoare triple {7666#false} assume 0 == ~cond; {7666#false} is VALID [2018-11-23 12:10:39,491 INFO L273 TraceCheckUtils]: 39: Hoare triple {7666#false} assume !false; {7666#false} is VALID [2018-11-23 12:10:39,492 INFO L134 CoverageAnalysis]: Checked inductivity of 378 backedges. 0 proven. 378 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:39,514 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:39,514 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [30, 30] total 31 [2018-11-23 12:10:39,514 INFO L78 Accepts]: Start accepts. Automaton has 31 states. Word has length 40 [2018-11-23 12:10:39,514 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:39,514 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 31 states. [2018-11-23 12:10:39,546 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:10:39,546 INFO L459 AbstractCegarLoop]: Interpolant automaton has 31 states [2018-11-23 12:10:39,546 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 31 interpolants. [2018-11-23 12:10:39,547 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=465, Invalid=465, Unknown=0, NotChecked=0, Total=930 [2018-11-23 12:10:39,547 INFO L87 Difference]: Start difference. First operand 45 states and 46 transitions. Second operand 31 states. [2018-11-23 12:10:39,833 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:39,833 INFO L93 Difference]: Finished difference Result 57 states and 59 transitions. [2018-11-23 12:10:39,833 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 30 states. [2018-11-23 12:10:39,833 INFO L78 Accepts]: Start accepts. Automaton has 31 states. Word has length 40 [2018-11-23 12:10:39,834 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:39,834 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 31 states. [2018-11-23 12:10:39,836 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 30 states to 30 states and 59 transitions. [2018-11-23 12:10:39,836 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 31 states. [2018-11-23 12:10:39,837 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 30 states to 30 states and 59 transitions. [2018-11-23 12:10:39,837 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 30 states and 59 transitions. [2018-11-23 12:10:39,892 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 59 edges. 59 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:39,893 INFO L225 Difference]: With dead ends: 57 [2018-11-23 12:10:39,893 INFO L226 Difference]: Without dead ends: 46 [2018-11-23 12:10:39,894 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 69 GetRequests, 40 SyntacticMatches, 0 SemanticMatches, 29 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 52 ImplicationChecksByTransitivity, 0.7s TimeCoverageRelationStatistics Valid=465, Invalid=465, Unknown=0, NotChecked=0, Total=930 [2018-11-23 12:10:39,895 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 46 states. [2018-11-23 12:10:39,923 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 46 to 46. [2018-11-23 12:10:39,923 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:39,924 INFO L82 GeneralOperation]: Start isEquivalent. First operand 46 states. Second operand 46 states. [2018-11-23 12:10:39,924 INFO L74 IsIncluded]: Start isIncluded. First operand 46 states. Second operand 46 states. [2018-11-23 12:10:39,924 INFO L87 Difference]: Start difference. First operand 46 states. Second operand 46 states. [2018-11-23 12:10:39,925 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:39,925 INFO L93 Difference]: Finished difference Result 46 states and 47 transitions. [2018-11-23 12:10:39,925 INFO L276 IsEmpty]: Start isEmpty. Operand 46 states and 47 transitions. [2018-11-23 12:10:39,925 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:39,926 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:39,926 INFO L74 IsIncluded]: Start isIncluded. First operand 46 states. Second operand 46 states. [2018-11-23 12:10:39,926 INFO L87 Difference]: Start difference. First operand 46 states. Second operand 46 states. [2018-11-23 12:10:39,927 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:39,927 INFO L93 Difference]: Finished difference Result 46 states and 47 transitions. [2018-11-23 12:10:39,927 INFO L276 IsEmpty]: Start isEmpty. Operand 46 states and 47 transitions. [2018-11-23 12:10:39,927 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:39,928 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:39,928 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:39,928 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:39,928 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 46 states. [2018-11-23 12:10:39,928 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 46 states to 46 states and 47 transitions. [2018-11-23 12:10:39,929 INFO L78 Accepts]: Start accepts. Automaton has 46 states and 47 transitions. Word has length 40 [2018-11-23 12:10:39,929 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:39,929 INFO L480 AbstractCegarLoop]: Abstraction has 46 states and 47 transitions. [2018-11-23 12:10:39,929 INFO L481 AbstractCegarLoop]: Interpolant automaton has 31 states. [2018-11-23 12:10:39,929 INFO L276 IsEmpty]: Start isEmpty. Operand 46 states and 47 transitions. [2018-11-23 12:10:39,930 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 42 [2018-11-23 12:10:39,930 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:39,930 INFO L402 BasicCegarLoop]: trace histogram [28, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:39,930 INFO L423 AbstractCegarLoop]: === Iteration 30 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:39,930 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:39,931 INFO L82 PathProgramCache]: Analyzing trace with hash 891243698, now seen corresponding path program 28 times [2018-11-23 12:10:39,931 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:39,931 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:39,932 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:39,932 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:39,932 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:39,962 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:40,637 INFO L256 TraceCheckUtils]: 0: Hoare triple {8085#true} call ULTIMATE.init(); {8085#true} is VALID [2018-11-23 12:10:40,637 INFO L273 TraceCheckUtils]: 1: Hoare triple {8085#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {8085#true} is VALID [2018-11-23 12:10:40,637 INFO L273 TraceCheckUtils]: 2: Hoare triple {8085#true} assume true; {8085#true} is VALID [2018-11-23 12:10:40,638 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {8085#true} {8085#true} #48#return; {8085#true} is VALID [2018-11-23 12:10:40,638 INFO L256 TraceCheckUtils]: 4: Hoare triple {8085#true} call #t~ret6 := main(); {8085#true} is VALID [2018-11-23 12:10:40,638 INFO L273 TraceCheckUtils]: 5: Hoare triple {8085#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {8087#(= main_~i~0 0)} is VALID [2018-11-23 12:10:40,639 INFO L273 TraceCheckUtils]: 6: Hoare triple {8087#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8088#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:40,640 INFO L273 TraceCheckUtils]: 7: Hoare triple {8088#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8089#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:40,641 INFO L273 TraceCheckUtils]: 8: Hoare triple {8089#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8090#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:40,643 INFO L273 TraceCheckUtils]: 9: Hoare triple {8090#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8091#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:40,644 INFO L273 TraceCheckUtils]: 10: Hoare triple {8091#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8092#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:40,645 INFO L273 TraceCheckUtils]: 11: Hoare triple {8092#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8093#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:40,646 INFO L273 TraceCheckUtils]: 12: Hoare triple {8093#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8094#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:40,647 INFO L273 TraceCheckUtils]: 13: Hoare triple {8094#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8095#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:40,647 INFO L273 TraceCheckUtils]: 14: Hoare triple {8095#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8096#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:40,649 INFO L273 TraceCheckUtils]: 15: Hoare triple {8096#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8097#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:40,649 INFO L273 TraceCheckUtils]: 16: Hoare triple {8097#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8098#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:40,650 INFO L273 TraceCheckUtils]: 17: Hoare triple {8098#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8099#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:40,651 INFO L273 TraceCheckUtils]: 18: Hoare triple {8099#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8100#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:40,652 INFO L273 TraceCheckUtils]: 19: Hoare triple {8100#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8101#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:40,654 INFO L273 TraceCheckUtils]: 20: Hoare triple {8101#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8102#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:40,655 INFO L273 TraceCheckUtils]: 21: Hoare triple {8102#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8103#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:40,656 INFO L273 TraceCheckUtils]: 22: Hoare triple {8103#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8104#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:40,657 INFO L273 TraceCheckUtils]: 23: Hoare triple {8104#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8105#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:40,658 INFO L273 TraceCheckUtils]: 24: Hoare triple {8105#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8106#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:40,659 INFO L273 TraceCheckUtils]: 25: Hoare triple {8106#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8107#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:40,660 INFO L273 TraceCheckUtils]: 26: Hoare triple {8107#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8108#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:40,661 INFO L273 TraceCheckUtils]: 27: Hoare triple {8108#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8109#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:40,662 INFO L273 TraceCheckUtils]: 28: Hoare triple {8109#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8110#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:40,663 INFO L273 TraceCheckUtils]: 29: Hoare triple {8110#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8111#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:40,664 INFO L273 TraceCheckUtils]: 30: Hoare triple {8111#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8112#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:40,665 INFO L273 TraceCheckUtils]: 31: Hoare triple {8112#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8113#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:40,666 INFO L273 TraceCheckUtils]: 32: Hoare triple {8113#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8114#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:40,667 INFO L273 TraceCheckUtils]: 33: Hoare triple {8114#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8115#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:40,668 INFO L273 TraceCheckUtils]: 34: Hoare triple {8115#(<= main_~i~0 28)} assume !(~i~0 < 100000); {8086#false} is VALID [2018-11-23 12:10:40,668 INFO L273 TraceCheckUtils]: 35: Hoare triple {8086#false} havoc ~x~0;~x~0 := 0; {8086#false} is VALID [2018-11-23 12:10:40,669 INFO L273 TraceCheckUtils]: 36: Hoare triple {8086#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {8086#false} is VALID [2018-11-23 12:10:40,669 INFO L256 TraceCheckUtils]: 37: Hoare triple {8086#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {8086#false} is VALID [2018-11-23 12:10:40,669 INFO L273 TraceCheckUtils]: 38: Hoare triple {8086#false} ~cond := #in~cond; {8086#false} is VALID [2018-11-23 12:10:40,669 INFO L273 TraceCheckUtils]: 39: Hoare triple {8086#false} assume 0 == ~cond; {8086#false} is VALID [2018-11-23 12:10:40,669 INFO L273 TraceCheckUtils]: 40: Hoare triple {8086#false} assume !false; {8086#false} is VALID [2018-11-23 12:10:40,671 INFO L134 CoverageAnalysis]: Checked inductivity of 406 backedges. 0 proven. 406 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:40,671 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:40,672 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:40,680 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:10:40,715 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:10:40,715 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:40,730 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:40,731 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:40,897 INFO L256 TraceCheckUtils]: 0: Hoare triple {8085#true} call ULTIMATE.init(); {8085#true} is VALID [2018-11-23 12:10:40,897 INFO L273 TraceCheckUtils]: 1: Hoare triple {8085#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {8085#true} is VALID [2018-11-23 12:10:40,897 INFO L273 TraceCheckUtils]: 2: Hoare triple {8085#true} assume true; {8085#true} is VALID [2018-11-23 12:10:40,897 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {8085#true} {8085#true} #48#return; {8085#true} is VALID [2018-11-23 12:10:40,898 INFO L256 TraceCheckUtils]: 4: Hoare triple {8085#true} call #t~ret6 := main(); {8085#true} is VALID [2018-11-23 12:10:40,899 INFO L273 TraceCheckUtils]: 5: Hoare triple {8085#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {8134#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:40,900 INFO L273 TraceCheckUtils]: 6: Hoare triple {8134#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8088#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:40,901 INFO L273 TraceCheckUtils]: 7: Hoare triple {8088#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8089#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:40,901 INFO L273 TraceCheckUtils]: 8: Hoare triple {8089#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8090#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:40,902 INFO L273 TraceCheckUtils]: 9: Hoare triple {8090#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8091#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:40,902 INFO L273 TraceCheckUtils]: 10: Hoare triple {8091#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8092#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:40,903 INFO L273 TraceCheckUtils]: 11: Hoare triple {8092#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8093#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:40,904 INFO L273 TraceCheckUtils]: 12: Hoare triple {8093#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8094#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:40,905 INFO L273 TraceCheckUtils]: 13: Hoare triple {8094#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8095#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:40,906 INFO L273 TraceCheckUtils]: 14: Hoare triple {8095#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8096#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:40,908 INFO L273 TraceCheckUtils]: 15: Hoare triple {8096#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8097#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:40,909 INFO L273 TraceCheckUtils]: 16: Hoare triple {8097#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8098#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:40,910 INFO L273 TraceCheckUtils]: 17: Hoare triple {8098#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8099#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:40,911 INFO L273 TraceCheckUtils]: 18: Hoare triple {8099#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8100#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:40,912 INFO L273 TraceCheckUtils]: 19: Hoare triple {8100#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8101#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:40,913 INFO L273 TraceCheckUtils]: 20: Hoare triple {8101#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8102#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:40,914 INFO L273 TraceCheckUtils]: 21: Hoare triple {8102#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8103#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:40,915 INFO L273 TraceCheckUtils]: 22: Hoare triple {8103#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8104#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:40,916 INFO L273 TraceCheckUtils]: 23: Hoare triple {8104#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8105#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:40,917 INFO L273 TraceCheckUtils]: 24: Hoare triple {8105#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8106#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:40,918 INFO L273 TraceCheckUtils]: 25: Hoare triple {8106#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8107#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:40,919 INFO L273 TraceCheckUtils]: 26: Hoare triple {8107#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8108#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:40,920 INFO L273 TraceCheckUtils]: 27: Hoare triple {8108#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8109#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:40,921 INFO L273 TraceCheckUtils]: 28: Hoare triple {8109#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8110#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:40,922 INFO L273 TraceCheckUtils]: 29: Hoare triple {8110#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8111#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:40,923 INFO L273 TraceCheckUtils]: 30: Hoare triple {8111#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8112#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:40,925 INFO L273 TraceCheckUtils]: 31: Hoare triple {8112#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8113#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:40,926 INFO L273 TraceCheckUtils]: 32: Hoare triple {8113#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8114#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:40,927 INFO L273 TraceCheckUtils]: 33: Hoare triple {8114#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8115#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:40,927 INFO L273 TraceCheckUtils]: 34: Hoare triple {8115#(<= main_~i~0 28)} assume !(~i~0 < 100000); {8086#false} is VALID [2018-11-23 12:10:40,928 INFO L273 TraceCheckUtils]: 35: Hoare triple {8086#false} havoc ~x~0;~x~0 := 0; {8086#false} is VALID [2018-11-23 12:10:40,928 INFO L273 TraceCheckUtils]: 36: Hoare triple {8086#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {8086#false} is VALID [2018-11-23 12:10:40,928 INFO L256 TraceCheckUtils]: 37: Hoare triple {8086#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {8086#false} is VALID [2018-11-23 12:10:40,928 INFO L273 TraceCheckUtils]: 38: Hoare triple {8086#false} ~cond := #in~cond; {8086#false} is VALID [2018-11-23 12:10:40,928 INFO L273 TraceCheckUtils]: 39: Hoare triple {8086#false} assume 0 == ~cond; {8086#false} is VALID [2018-11-23 12:10:40,929 INFO L273 TraceCheckUtils]: 40: Hoare triple {8086#false} assume !false; {8086#false} is VALID [2018-11-23 12:10:40,931 INFO L134 CoverageAnalysis]: Checked inductivity of 406 backedges. 0 proven. 406 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:40,949 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:40,949 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [31, 31] total 32 [2018-11-23 12:10:40,950 INFO L78 Accepts]: Start accepts. Automaton has 32 states. Word has length 41 [2018-11-23 12:10:40,950 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:40,950 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 32 states. [2018-11-23 12:10:40,981 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:10:40,981 INFO L459 AbstractCegarLoop]: Interpolant automaton has 32 states [2018-11-23 12:10:40,981 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 32 interpolants. [2018-11-23 12:10:40,982 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=496, Invalid=496, Unknown=0, NotChecked=0, Total=992 [2018-11-23 12:10:40,982 INFO L87 Difference]: Start difference. First operand 46 states and 47 transitions. Second operand 32 states. [2018-11-23 12:10:41,557 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:41,557 INFO L93 Difference]: Finished difference Result 58 states and 60 transitions. [2018-11-23 12:10:41,557 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 31 states. [2018-11-23 12:10:41,558 INFO L78 Accepts]: Start accepts. Automaton has 32 states. Word has length 41 [2018-11-23 12:10:41,558 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:41,558 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 32 states. [2018-11-23 12:10:41,559 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 31 states to 31 states and 60 transitions. [2018-11-23 12:10:41,559 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 32 states. [2018-11-23 12:10:41,561 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 31 states to 31 states and 60 transitions. [2018-11-23 12:10:41,561 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 31 states and 60 transitions. [2018-11-23 12:10:41,608 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 60 edges. 60 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:41,609 INFO L225 Difference]: With dead ends: 58 [2018-11-23 12:10:41,609 INFO L226 Difference]: Without dead ends: 47 [2018-11-23 12:10:41,610 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 71 GetRequests, 41 SyntacticMatches, 0 SemanticMatches, 30 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 54 ImplicationChecksByTransitivity, 0.5s TimeCoverageRelationStatistics Valid=496, Invalid=496, Unknown=0, NotChecked=0, Total=992 [2018-11-23 12:10:41,610 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 47 states. [2018-11-23 12:10:41,635 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 47 to 47. [2018-11-23 12:10:41,635 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:41,635 INFO L82 GeneralOperation]: Start isEquivalent. First operand 47 states. Second operand 47 states. [2018-11-23 12:10:41,635 INFO L74 IsIncluded]: Start isIncluded. First operand 47 states. Second operand 47 states. [2018-11-23 12:10:41,636 INFO L87 Difference]: Start difference. First operand 47 states. Second operand 47 states. [2018-11-23 12:10:41,637 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:41,637 INFO L93 Difference]: Finished difference Result 47 states and 48 transitions. [2018-11-23 12:10:41,637 INFO L276 IsEmpty]: Start isEmpty. Operand 47 states and 48 transitions. [2018-11-23 12:10:41,637 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:41,638 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:41,638 INFO L74 IsIncluded]: Start isIncluded. First operand 47 states. Second operand 47 states. [2018-11-23 12:10:41,638 INFO L87 Difference]: Start difference. First operand 47 states. Second operand 47 states. [2018-11-23 12:10:41,639 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:41,639 INFO L93 Difference]: Finished difference Result 47 states and 48 transitions. [2018-11-23 12:10:41,639 INFO L276 IsEmpty]: Start isEmpty. Operand 47 states and 48 transitions. [2018-11-23 12:10:41,639 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:41,639 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:41,639 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:41,639 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:41,640 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 47 states. [2018-11-23 12:10:41,640 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 47 states to 47 states and 48 transitions. [2018-11-23 12:10:41,640 INFO L78 Accepts]: Start accepts. Automaton has 47 states and 48 transitions. Word has length 41 [2018-11-23 12:10:41,640 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:41,641 INFO L480 AbstractCegarLoop]: Abstraction has 47 states and 48 transitions. [2018-11-23 12:10:41,641 INFO L481 AbstractCegarLoop]: Interpolant automaton has 32 states. [2018-11-23 12:10:41,641 INFO L276 IsEmpty]: Start isEmpty. Operand 47 states and 48 transitions. [2018-11-23 12:10:41,641 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 43 [2018-11-23 12:10:41,641 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:41,641 INFO L402 BasicCegarLoop]: trace histogram [29, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:41,641 INFO L423 AbstractCegarLoop]: === Iteration 31 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:41,642 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:41,642 INFO L82 PathProgramCache]: Analyzing trace with hash -232327826, now seen corresponding path program 29 times [2018-11-23 12:10:41,642 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:41,642 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:41,642 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:41,642 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:41,642 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:41,667 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:42,259 INFO L256 TraceCheckUtils]: 0: Hoare triple {8515#true} call ULTIMATE.init(); {8515#true} is VALID [2018-11-23 12:10:42,260 INFO L273 TraceCheckUtils]: 1: Hoare triple {8515#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {8515#true} is VALID [2018-11-23 12:10:42,260 INFO L273 TraceCheckUtils]: 2: Hoare triple {8515#true} assume true; {8515#true} is VALID [2018-11-23 12:10:42,260 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {8515#true} {8515#true} #48#return; {8515#true} is VALID [2018-11-23 12:10:42,261 INFO L256 TraceCheckUtils]: 4: Hoare triple {8515#true} call #t~ret6 := main(); {8515#true} is VALID [2018-11-23 12:10:42,261 INFO L273 TraceCheckUtils]: 5: Hoare triple {8515#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {8517#(= main_~i~0 0)} is VALID [2018-11-23 12:10:42,262 INFO L273 TraceCheckUtils]: 6: Hoare triple {8517#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8518#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:42,263 INFO L273 TraceCheckUtils]: 7: Hoare triple {8518#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8519#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:42,263 INFO L273 TraceCheckUtils]: 8: Hoare triple {8519#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8520#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:42,264 INFO L273 TraceCheckUtils]: 9: Hoare triple {8520#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8521#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:42,265 INFO L273 TraceCheckUtils]: 10: Hoare triple {8521#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8522#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:42,266 INFO L273 TraceCheckUtils]: 11: Hoare triple {8522#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8523#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:42,267 INFO L273 TraceCheckUtils]: 12: Hoare triple {8523#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8524#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:42,268 INFO L273 TraceCheckUtils]: 13: Hoare triple {8524#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8525#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:42,269 INFO L273 TraceCheckUtils]: 14: Hoare triple {8525#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8526#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:42,270 INFO L273 TraceCheckUtils]: 15: Hoare triple {8526#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8527#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:42,271 INFO L273 TraceCheckUtils]: 16: Hoare triple {8527#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8528#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:42,272 INFO L273 TraceCheckUtils]: 17: Hoare triple {8528#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8529#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:42,273 INFO L273 TraceCheckUtils]: 18: Hoare triple {8529#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8530#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:42,274 INFO L273 TraceCheckUtils]: 19: Hoare triple {8530#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8531#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:42,275 INFO L273 TraceCheckUtils]: 20: Hoare triple {8531#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8532#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:42,276 INFO L273 TraceCheckUtils]: 21: Hoare triple {8532#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8533#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:42,277 INFO L273 TraceCheckUtils]: 22: Hoare triple {8533#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8534#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:42,278 INFO L273 TraceCheckUtils]: 23: Hoare triple {8534#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8535#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:42,279 INFO L273 TraceCheckUtils]: 24: Hoare triple {8535#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8536#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:42,280 INFO L273 TraceCheckUtils]: 25: Hoare triple {8536#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8537#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:42,281 INFO L273 TraceCheckUtils]: 26: Hoare triple {8537#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8538#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:42,283 INFO L273 TraceCheckUtils]: 27: Hoare triple {8538#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8539#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:42,284 INFO L273 TraceCheckUtils]: 28: Hoare triple {8539#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8540#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:42,285 INFO L273 TraceCheckUtils]: 29: Hoare triple {8540#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8541#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:42,286 INFO L273 TraceCheckUtils]: 30: Hoare triple {8541#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8542#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:42,287 INFO L273 TraceCheckUtils]: 31: Hoare triple {8542#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8543#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:42,288 INFO L273 TraceCheckUtils]: 32: Hoare triple {8543#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8544#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:42,289 INFO L273 TraceCheckUtils]: 33: Hoare triple {8544#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8545#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:42,290 INFO L273 TraceCheckUtils]: 34: Hoare triple {8545#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8546#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:42,291 INFO L273 TraceCheckUtils]: 35: Hoare triple {8546#(<= main_~i~0 29)} assume !(~i~0 < 100000); {8516#false} is VALID [2018-11-23 12:10:42,291 INFO L273 TraceCheckUtils]: 36: Hoare triple {8516#false} havoc ~x~0;~x~0 := 0; {8516#false} is VALID [2018-11-23 12:10:42,291 INFO L273 TraceCheckUtils]: 37: Hoare triple {8516#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {8516#false} is VALID [2018-11-23 12:10:42,291 INFO L256 TraceCheckUtils]: 38: Hoare triple {8516#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {8516#false} is VALID [2018-11-23 12:10:42,292 INFO L273 TraceCheckUtils]: 39: Hoare triple {8516#false} ~cond := #in~cond; {8516#false} is VALID [2018-11-23 12:10:42,292 INFO L273 TraceCheckUtils]: 40: Hoare triple {8516#false} assume 0 == ~cond; {8516#false} is VALID [2018-11-23 12:10:42,292 INFO L273 TraceCheckUtils]: 41: Hoare triple {8516#false} assume !false; {8516#false} is VALID [2018-11-23 12:10:42,294 INFO L134 CoverageAnalysis]: Checked inductivity of 435 backedges. 0 proven. 435 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:42,295 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:42,295 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:42,303 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:10:42,947 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 16 check-sat command(s) [2018-11-23 12:10:42,947 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:42,964 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:42,965 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:43,138 INFO L256 TraceCheckUtils]: 0: Hoare triple {8515#true} call ULTIMATE.init(); {8515#true} is VALID [2018-11-23 12:10:43,138 INFO L273 TraceCheckUtils]: 1: Hoare triple {8515#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {8515#true} is VALID [2018-11-23 12:10:43,139 INFO L273 TraceCheckUtils]: 2: Hoare triple {8515#true} assume true; {8515#true} is VALID [2018-11-23 12:10:43,139 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {8515#true} {8515#true} #48#return; {8515#true} is VALID [2018-11-23 12:10:43,139 INFO L256 TraceCheckUtils]: 4: Hoare triple {8515#true} call #t~ret6 := main(); {8515#true} is VALID [2018-11-23 12:10:43,140 INFO L273 TraceCheckUtils]: 5: Hoare triple {8515#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {8565#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:43,141 INFO L273 TraceCheckUtils]: 6: Hoare triple {8565#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8518#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:43,142 INFO L273 TraceCheckUtils]: 7: Hoare triple {8518#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8519#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:43,142 INFO L273 TraceCheckUtils]: 8: Hoare triple {8519#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8520#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:43,143 INFO L273 TraceCheckUtils]: 9: Hoare triple {8520#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8521#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:43,144 INFO L273 TraceCheckUtils]: 10: Hoare triple {8521#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8522#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:43,145 INFO L273 TraceCheckUtils]: 11: Hoare triple {8522#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8523#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:43,146 INFO L273 TraceCheckUtils]: 12: Hoare triple {8523#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8524#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:43,147 INFO L273 TraceCheckUtils]: 13: Hoare triple {8524#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8525#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:43,148 INFO L273 TraceCheckUtils]: 14: Hoare triple {8525#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8526#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:43,161 INFO L273 TraceCheckUtils]: 15: Hoare triple {8526#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8527#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:43,162 INFO L273 TraceCheckUtils]: 16: Hoare triple {8527#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8528#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:43,162 INFO L273 TraceCheckUtils]: 17: Hoare triple {8528#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8529#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:43,163 INFO L273 TraceCheckUtils]: 18: Hoare triple {8529#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8530#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:43,164 INFO L273 TraceCheckUtils]: 19: Hoare triple {8530#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8531#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:43,164 INFO L273 TraceCheckUtils]: 20: Hoare triple {8531#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8532#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:43,165 INFO L273 TraceCheckUtils]: 21: Hoare triple {8532#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8533#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:43,166 INFO L273 TraceCheckUtils]: 22: Hoare triple {8533#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8534#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:43,167 INFO L273 TraceCheckUtils]: 23: Hoare triple {8534#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8535#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:43,168 INFO L273 TraceCheckUtils]: 24: Hoare triple {8535#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8536#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:43,169 INFO L273 TraceCheckUtils]: 25: Hoare triple {8536#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8537#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:43,170 INFO L273 TraceCheckUtils]: 26: Hoare triple {8537#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8538#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:43,171 INFO L273 TraceCheckUtils]: 27: Hoare triple {8538#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8539#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:43,172 INFO L273 TraceCheckUtils]: 28: Hoare triple {8539#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8540#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:43,173 INFO L273 TraceCheckUtils]: 29: Hoare triple {8540#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8541#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:43,174 INFO L273 TraceCheckUtils]: 30: Hoare triple {8541#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8542#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:43,175 INFO L273 TraceCheckUtils]: 31: Hoare triple {8542#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8543#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:43,176 INFO L273 TraceCheckUtils]: 32: Hoare triple {8543#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8544#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:43,177 INFO L273 TraceCheckUtils]: 33: Hoare triple {8544#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8545#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:43,178 INFO L273 TraceCheckUtils]: 34: Hoare triple {8545#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8546#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:43,178 INFO L273 TraceCheckUtils]: 35: Hoare triple {8546#(<= main_~i~0 29)} assume !(~i~0 < 100000); {8516#false} is VALID [2018-11-23 12:10:43,179 INFO L273 TraceCheckUtils]: 36: Hoare triple {8516#false} havoc ~x~0;~x~0 := 0; {8516#false} is VALID [2018-11-23 12:10:43,179 INFO L273 TraceCheckUtils]: 37: Hoare triple {8516#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {8516#false} is VALID [2018-11-23 12:10:43,179 INFO L256 TraceCheckUtils]: 38: Hoare triple {8516#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {8516#false} is VALID [2018-11-23 12:10:43,179 INFO L273 TraceCheckUtils]: 39: Hoare triple {8516#false} ~cond := #in~cond; {8516#false} is VALID [2018-11-23 12:10:43,179 INFO L273 TraceCheckUtils]: 40: Hoare triple {8516#false} assume 0 == ~cond; {8516#false} is VALID [2018-11-23 12:10:43,180 INFO L273 TraceCheckUtils]: 41: Hoare triple {8516#false} assume !false; {8516#false} is VALID [2018-11-23 12:10:43,182 INFO L134 CoverageAnalysis]: Checked inductivity of 435 backedges. 0 proven. 435 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:43,202 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:43,202 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [32, 32] total 33 [2018-11-23 12:10:43,202 INFO L78 Accepts]: Start accepts. Automaton has 33 states. Word has length 42 [2018-11-23 12:10:43,202 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:43,202 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 33 states. [2018-11-23 12:10:43,234 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 44 edges. 44 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:43,235 INFO L459 AbstractCegarLoop]: Interpolant automaton has 33 states [2018-11-23 12:10:43,235 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 33 interpolants. [2018-11-23 12:10:43,236 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=528, Invalid=528, Unknown=0, NotChecked=0, Total=1056 [2018-11-23 12:10:43,236 INFO L87 Difference]: Start difference. First operand 47 states and 48 transitions. Second operand 33 states. [2018-11-23 12:10:43,900 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:43,900 INFO L93 Difference]: Finished difference Result 59 states and 61 transitions. [2018-11-23 12:10:43,900 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 32 states. [2018-11-23 12:10:43,900 INFO L78 Accepts]: Start accepts. Automaton has 33 states. Word has length 42 [2018-11-23 12:10:43,900 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:43,901 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 33 states. [2018-11-23 12:10:43,902 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 32 states to 32 states and 61 transitions. [2018-11-23 12:10:43,902 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 33 states. [2018-11-23 12:10:43,903 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 32 states to 32 states and 61 transitions. [2018-11-23 12:10:43,903 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 32 states and 61 transitions. [2018-11-23 12:10:43,949 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 61 edges. 61 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:43,950 INFO L225 Difference]: With dead ends: 59 [2018-11-23 12:10:43,950 INFO L226 Difference]: Without dead ends: 48 [2018-11-23 12:10:43,951 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 73 GetRequests, 42 SyntacticMatches, 0 SemanticMatches, 31 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 56 ImplicationChecksByTransitivity, 0.4s TimeCoverageRelationStatistics Valid=528, Invalid=528, Unknown=0, NotChecked=0, Total=1056 [2018-11-23 12:10:43,952 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 48 states. [2018-11-23 12:10:43,982 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 48 to 48. [2018-11-23 12:10:43,982 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:43,982 INFO L82 GeneralOperation]: Start isEquivalent. First operand 48 states. Second operand 48 states. [2018-11-23 12:10:43,982 INFO L74 IsIncluded]: Start isIncluded. First operand 48 states. Second operand 48 states. [2018-11-23 12:10:43,982 INFO L87 Difference]: Start difference. First operand 48 states. Second operand 48 states. [2018-11-23 12:10:43,983 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:43,983 INFO L93 Difference]: Finished difference Result 48 states and 49 transitions. [2018-11-23 12:10:43,983 INFO L276 IsEmpty]: Start isEmpty. Operand 48 states and 49 transitions. [2018-11-23 12:10:43,983 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:43,983 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:43,983 INFO L74 IsIncluded]: Start isIncluded. First operand 48 states. Second operand 48 states. [2018-11-23 12:10:43,983 INFO L87 Difference]: Start difference. First operand 48 states. Second operand 48 states. [2018-11-23 12:10:43,984 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:43,984 INFO L93 Difference]: Finished difference Result 48 states and 49 transitions. [2018-11-23 12:10:43,984 INFO L276 IsEmpty]: Start isEmpty. Operand 48 states and 49 transitions. [2018-11-23 12:10:43,985 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:43,985 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:43,985 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:43,985 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:43,985 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 48 states. [2018-11-23 12:10:43,985 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 48 states to 48 states and 49 transitions. [2018-11-23 12:10:43,985 INFO L78 Accepts]: Start accepts. Automaton has 48 states and 49 transitions. Word has length 42 [2018-11-23 12:10:43,986 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:43,986 INFO L480 AbstractCegarLoop]: Abstraction has 48 states and 49 transitions. [2018-11-23 12:10:43,986 INFO L481 AbstractCegarLoop]: Interpolant automaton has 33 states. [2018-11-23 12:10:43,986 INFO L276 IsEmpty]: Start isEmpty. Operand 48 states and 49 transitions. [2018-11-23 12:10:43,986 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 44 [2018-11-23 12:10:43,986 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:43,986 INFO L402 BasicCegarLoop]: trace histogram [30, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:43,987 INFO L423 AbstractCegarLoop]: === Iteration 32 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:43,987 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:43,987 INFO L82 PathProgramCache]: Analyzing trace with hash -703306702, now seen corresponding path program 30 times [2018-11-23 12:10:43,987 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:43,987 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:43,988 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:43,988 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:43,988 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:44,015 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:44,830 INFO L256 TraceCheckUtils]: 0: Hoare triple {8955#true} call ULTIMATE.init(); {8955#true} is VALID [2018-11-23 12:10:44,831 INFO L273 TraceCheckUtils]: 1: Hoare triple {8955#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {8955#true} is VALID [2018-11-23 12:10:44,831 INFO L273 TraceCheckUtils]: 2: Hoare triple {8955#true} assume true; {8955#true} is VALID [2018-11-23 12:10:44,831 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {8955#true} {8955#true} #48#return; {8955#true} is VALID [2018-11-23 12:10:44,831 INFO L256 TraceCheckUtils]: 4: Hoare triple {8955#true} call #t~ret6 := main(); {8955#true} is VALID [2018-11-23 12:10:44,832 INFO L273 TraceCheckUtils]: 5: Hoare triple {8955#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {8957#(= main_~i~0 0)} is VALID [2018-11-23 12:10:44,833 INFO L273 TraceCheckUtils]: 6: Hoare triple {8957#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8958#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:44,834 INFO L273 TraceCheckUtils]: 7: Hoare triple {8958#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8959#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:44,835 INFO L273 TraceCheckUtils]: 8: Hoare triple {8959#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8960#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:44,836 INFO L273 TraceCheckUtils]: 9: Hoare triple {8960#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8961#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:44,837 INFO L273 TraceCheckUtils]: 10: Hoare triple {8961#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8962#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:44,838 INFO L273 TraceCheckUtils]: 11: Hoare triple {8962#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8963#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:44,839 INFO L273 TraceCheckUtils]: 12: Hoare triple {8963#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8964#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:44,840 INFO L273 TraceCheckUtils]: 13: Hoare triple {8964#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8965#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:44,842 INFO L273 TraceCheckUtils]: 14: Hoare triple {8965#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8966#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:44,843 INFO L273 TraceCheckUtils]: 15: Hoare triple {8966#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8967#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:44,844 INFO L273 TraceCheckUtils]: 16: Hoare triple {8967#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8968#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:44,845 INFO L273 TraceCheckUtils]: 17: Hoare triple {8968#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8969#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:44,846 INFO L273 TraceCheckUtils]: 18: Hoare triple {8969#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8970#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:44,847 INFO L273 TraceCheckUtils]: 19: Hoare triple {8970#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8971#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:44,848 INFO L273 TraceCheckUtils]: 20: Hoare triple {8971#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8972#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:44,849 INFO L273 TraceCheckUtils]: 21: Hoare triple {8972#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8973#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:44,850 INFO L273 TraceCheckUtils]: 22: Hoare triple {8973#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8974#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:44,851 INFO L273 TraceCheckUtils]: 23: Hoare triple {8974#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8975#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:44,852 INFO L273 TraceCheckUtils]: 24: Hoare triple {8975#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8976#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:44,853 INFO L273 TraceCheckUtils]: 25: Hoare triple {8976#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8977#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:44,854 INFO L273 TraceCheckUtils]: 26: Hoare triple {8977#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8978#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:44,855 INFO L273 TraceCheckUtils]: 27: Hoare triple {8978#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8979#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:44,856 INFO L273 TraceCheckUtils]: 28: Hoare triple {8979#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8980#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:44,857 INFO L273 TraceCheckUtils]: 29: Hoare triple {8980#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8981#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:44,858 INFO L273 TraceCheckUtils]: 30: Hoare triple {8981#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8982#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:44,859 INFO L273 TraceCheckUtils]: 31: Hoare triple {8982#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8983#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:44,860 INFO L273 TraceCheckUtils]: 32: Hoare triple {8983#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8984#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:44,861 INFO L273 TraceCheckUtils]: 33: Hoare triple {8984#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8985#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:44,862 INFO L273 TraceCheckUtils]: 34: Hoare triple {8985#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8986#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:44,863 INFO L273 TraceCheckUtils]: 35: Hoare triple {8986#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8987#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:44,863 INFO L273 TraceCheckUtils]: 36: Hoare triple {8987#(<= main_~i~0 30)} assume !(~i~0 < 100000); {8956#false} is VALID [2018-11-23 12:10:44,864 INFO L273 TraceCheckUtils]: 37: Hoare triple {8956#false} havoc ~x~0;~x~0 := 0; {8956#false} is VALID [2018-11-23 12:10:44,864 INFO L273 TraceCheckUtils]: 38: Hoare triple {8956#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {8956#false} is VALID [2018-11-23 12:10:44,864 INFO L256 TraceCheckUtils]: 39: Hoare triple {8956#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {8956#false} is VALID [2018-11-23 12:10:44,864 INFO L273 TraceCheckUtils]: 40: Hoare triple {8956#false} ~cond := #in~cond; {8956#false} is VALID [2018-11-23 12:10:44,864 INFO L273 TraceCheckUtils]: 41: Hoare triple {8956#false} assume 0 == ~cond; {8956#false} is VALID [2018-11-23 12:10:44,864 INFO L273 TraceCheckUtils]: 42: Hoare triple {8956#false} assume !false; {8956#false} is VALID [2018-11-23 12:10:44,866 INFO L134 CoverageAnalysis]: Checked inductivity of 465 backedges. 0 proven. 465 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:44,866 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:44,867 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 31 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 31 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:44,875 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE [2018-11-23 12:10:54,927 INFO L249 tOrderPrioritization]: Assert order MIX_INSIDE_OUTSIDE issued 16 check-sat command(s) [2018-11-23 12:10:54,927 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:54,952 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:54,953 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:55,159 INFO L256 TraceCheckUtils]: 0: Hoare triple {8955#true} call ULTIMATE.init(); {8955#true} is VALID [2018-11-23 12:10:55,159 INFO L273 TraceCheckUtils]: 1: Hoare triple {8955#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {8955#true} is VALID [2018-11-23 12:10:55,160 INFO L273 TraceCheckUtils]: 2: Hoare triple {8955#true} assume true; {8955#true} is VALID [2018-11-23 12:10:55,160 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {8955#true} {8955#true} #48#return; {8955#true} is VALID [2018-11-23 12:10:55,160 INFO L256 TraceCheckUtils]: 4: Hoare triple {8955#true} call #t~ret6 := main(); {8955#true} is VALID [2018-11-23 12:10:55,161 INFO L273 TraceCheckUtils]: 5: Hoare triple {8955#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {9006#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:55,162 INFO L273 TraceCheckUtils]: 6: Hoare triple {9006#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8958#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:55,163 INFO L273 TraceCheckUtils]: 7: Hoare triple {8958#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8959#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:55,163 INFO L273 TraceCheckUtils]: 8: Hoare triple {8959#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8960#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:55,164 INFO L273 TraceCheckUtils]: 9: Hoare triple {8960#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8961#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:55,165 INFO L273 TraceCheckUtils]: 10: Hoare triple {8961#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8962#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:55,165 INFO L273 TraceCheckUtils]: 11: Hoare triple {8962#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8963#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:55,167 INFO L273 TraceCheckUtils]: 12: Hoare triple {8963#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8964#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:55,168 INFO L273 TraceCheckUtils]: 13: Hoare triple {8964#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8965#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:55,169 INFO L273 TraceCheckUtils]: 14: Hoare triple {8965#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8966#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:55,170 INFO L273 TraceCheckUtils]: 15: Hoare triple {8966#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8967#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:55,171 INFO L273 TraceCheckUtils]: 16: Hoare triple {8967#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8968#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:55,172 INFO L273 TraceCheckUtils]: 17: Hoare triple {8968#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8969#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:55,173 INFO L273 TraceCheckUtils]: 18: Hoare triple {8969#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8970#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:55,174 INFO L273 TraceCheckUtils]: 19: Hoare triple {8970#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8971#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:55,175 INFO L273 TraceCheckUtils]: 20: Hoare triple {8971#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8972#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:55,176 INFO L273 TraceCheckUtils]: 21: Hoare triple {8972#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8973#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:55,177 INFO L273 TraceCheckUtils]: 22: Hoare triple {8973#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8974#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:55,178 INFO L273 TraceCheckUtils]: 23: Hoare triple {8974#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8975#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:55,179 INFO L273 TraceCheckUtils]: 24: Hoare triple {8975#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8976#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:55,180 INFO L273 TraceCheckUtils]: 25: Hoare triple {8976#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8977#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:55,181 INFO L273 TraceCheckUtils]: 26: Hoare triple {8977#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8978#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:55,182 INFO L273 TraceCheckUtils]: 27: Hoare triple {8978#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8979#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:55,184 INFO L273 TraceCheckUtils]: 28: Hoare triple {8979#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8980#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:55,185 INFO L273 TraceCheckUtils]: 29: Hoare triple {8980#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8981#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:55,186 INFO L273 TraceCheckUtils]: 30: Hoare triple {8981#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8982#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:55,187 INFO L273 TraceCheckUtils]: 31: Hoare triple {8982#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8983#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:55,188 INFO L273 TraceCheckUtils]: 32: Hoare triple {8983#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8984#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:55,189 INFO L273 TraceCheckUtils]: 33: Hoare triple {8984#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8985#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:55,190 INFO L273 TraceCheckUtils]: 34: Hoare triple {8985#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8986#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:55,191 INFO L273 TraceCheckUtils]: 35: Hoare triple {8986#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {8987#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:55,192 INFO L273 TraceCheckUtils]: 36: Hoare triple {8987#(<= main_~i~0 30)} assume !(~i~0 < 100000); {8956#false} is VALID [2018-11-23 12:10:55,192 INFO L273 TraceCheckUtils]: 37: Hoare triple {8956#false} havoc ~x~0;~x~0 := 0; {8956#false} is VALID [2018-11-23 12:10:55,192 INFO L273 TraceCheckUtils]: 38: Hoare triple {8956#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {8956#false} is VALID [2018-11-23 12:10:55,192 INFO L256 TraceCheckUtils]: 39: Hoare triple {8956#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {8956#false} is VALID [2018-11-23 12:10:55,193 INFO L273 TraceCheckUtils]: 40: Hoare triple {8956#false} ~cond := #in~cond; {8956#false} is VALID [2018-11-23 12:10:55,193 INFO L273 TraceCheckUtils]: 41: Hoare triple {8956#false} assume 0 == ~cond; {8956#false} is VALID [2018-11-23 12:10:55,193 INFO L273 TraceCheckUtils]: 42: Hoare triple {8956#false} assume !false; {8956#false} is VALID [2018-11-23 12:10:55,195 INFO L134 CoverageAnalysis]: Checked inductivity of 465 backedges. 0 proven. 465 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:55,217 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:55,217 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [33, 33] total 34 [2018-11-23 12:10:55,217 INFO L78 Accepts]: Start accepts. Automaton has 34 states. Word has length 43 [2018-11-23 12:10:55,217 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:55,218 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 34 states. [2018-11-23 12:10:55,255 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 45 edges. 45 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:55,255 INFO L459 AbstractCegarLoop]: Interpolant automaton has 34 states [2018-11-23 12:10:55,255 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 34 interpolants. [2018-11-23 12:10:55,256 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=561, Invalid=561, Unknown=0, NotChecked=0, Total=1122 [2018-11-23 12:10:55,256 INFO L87 Difference]: Start difference. First operand 48 states and 49 transitions. Second operand 34 states. [2018-11-23 12:10:55,730 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:55,731 INFO L93 Difference]: Finished difference Result 60 states and 62 transitions. [2018-11-23 12:10:55,731 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 33 states. [2018-11-23 12:10:55,731 INFO L78 Accepts]: Start accepts. Automaton has 34 states. Word has length 43 [2018-11-23 12:10:55,732 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:55,732 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 34 states. [2018-11-23 12:10:55,734 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 33 states to 33 states and 62 transitions. [2018-11-23 12:10:55,734 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 34 states. [2018-11-23 12:10:55,735 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 33 states to 33 states and 62 transitions. [2018-11-23 12:10:55,735 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 33 states and 62 transitions. [2018-11-23 12:10:55,876 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 62 edges. 62 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:55,877 INFO L225 Difference]: With dead ends: 60 [2018-11-23 12:10:55,877 INFO L226 Difference]: Without dead ends: 49 [2018-11-23 12:10:55,878 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 75 GetRequests, 43 SyntacticMatches, 0 SemanticMatches, 32 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 58 ImplicationChecksByTransitivity, 0.6s TimeCoverageRelationStatistics Valid=561, Invalid=561, Unknown=0, NotChecked=0, Total=1122 [2018-11-23 12:10:55,879 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 49 states. [2018-11-23 12:10:55,902 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 49 to 49. [2018-11-23 12:10:55,902 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:55,902 INFO L82 GeneralOperation]: Start isEquivalent. First operand 49 states. Second operand 49 states. [2018-11-23 12:10:55,902 INFO L74 IsIncluded]: Start isIncluded. First operand 49 states. Second operand 49 states. [2018-11-23 12:10:55,902 INFO L87 Difference]: Start difference. First operand 49 states. Second operand 49 states. [2018-11-23 12:10:55,903 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:55,904 INFO L93 Difference]: Finished difference Result 49 states and 50 transitions. [2018-11-23 12:10:55,904 INFO L276 IsEmpty]: Start isEmpty. Operand 49 states and 50 transitions. [2018-11-23 12:10:55,904 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:55,904 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:55,904 INFO L74 IsIncluded]: Start isIncluded. First operand 49 states. Second operand 49 states. [2018-11-23 12:10:55,904 INFO L87 Difference]: Start difference. First operand 49 states. Second operand 49 states. [2018-11-23 12:10:55,905 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:55,905 INFO L93 Difference]: Finished difference Result 49 states and 50 transitions. [2018-11-23 12:10:55,906 INFO L276 IsEmpty]: Start isEmpty. Operand 49 states and 50 transitions. [2018-11-23 12:10:55,906 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:55,906 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:55,906 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:55,906 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:55,906 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 49 states. [2018-11-23 12:10:55,907 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 49 states to 49 states and 50 transitions. [2018-11-23 12:10:55,907 INFO L78 Accepts]: Start accepts. Automaton has 49 states and 50 transitions. Word has length 43 [2018-11-23 12:10:55,907 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:55,908 INFO L480 AbstractCegarLoop]: Abstraction has 49 states and 50 transitions. [2018-11-23 12:10:55,908 INFO L481 AbstractCegarLoop]: Interpolant automaton has 34 states. [2018-11-23 12:10:55,908 INFO L276 IsEmpty]: Start isEmpty. Operand 49 states and 50 transitions. [2018-11-23 12:10:55,908 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 45 [2018-11-23 12:10:55,908 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:55,908 INFO L402 BasicCegarLoop]: trace histogram [31, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:55,909 INFO L423 AbstractCegarLoop]: === Iteration 33 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:55,909 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:55,909 INFO L82 PathProgramCache]: Analyzing trace with hash 1876217326, now seen corresponding path program 31 times [2018-11-23 12:10:55,909 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:55,909 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:55,910 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:55,910 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:55,910 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:55,940 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:56,552 INFO L256 TraceCheckUtils]: 0: Hoare triple {9405#true} call ULTIMATE.init(); {9405#true} is VALID [2018-11-23 12:10:56,552 INFO L273 TraceCheckUtils]: 1: Hoare triple {9405#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {9405#true} is VALID [2018-11-23 12:10:56,553 INFO L273 TraceCheckUtils]: 2: Hoare triple {9405#true} assume true; {9405#true} is VALID [2018-11-23 12:10:56,553 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {9405#true} {9405#true} #48#return; {9405#true} is VALID [2018-11-23 12:10:56,553 INFO L256 TraceCheckUtils]: 4: Hoare triple {9405#true} call #t~ret6 := main(); {9405#true} is VALID [2018-11-23 12:10:56,554 INFO L273 TraceCheckUtils]: 5: Hoare triple {9405#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {9407#(= main_~i~0 0)} is VALID [2018-11-23 12:10:56,555 INFO L273 TraceCheckUtils]: 6: Hoare triple {9407#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9408#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:56,555 INFO L273 TraceCheckUtils]: 7: Hoare triple {9408#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9409#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:56,556 INFO L273 TraceCheckUtils]: 8: Hoare triple {9409#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9410#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:56,557 INFO L273 TraceCheckUtils]: 9: Hoare triple {9410#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9411#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:56,557 INFO L273 TraceCheckUtils]: 10: Hoare triple {9411#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9412#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:56,558 INFO L273 TraceCheckUtils]: 11: Hoare triple {9412#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9413#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:56,559 INFO L273 TraceCheckUtils]: 12: Hoare triple {9413#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9414#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:56,560 INFO L273 TraceCheckUtils]: 13: Hoare triple {9414#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9415#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:56,561 INFO L273 TraceCheckUtils]: 14: Hoare triple {9415#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9416#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:56,562 INFO L273 TraceCheckUtils]: 15: Hoare triple {9416#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9417#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:56,563 INFO L273 TraceCheckUtils]: 16: Hoare triple {9417#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9418#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:56,564 INFO L273 TraceCheckUtils]: 17: Hoare triple {9418#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9419#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:56,565 INFO L273 TraceCheckUtils]: 18: Hoare triple {9419#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9420#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:56,566 INFO L273 TraceCheckUtils]: 19: Hoare triple {9420#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9421#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:56,567 INFO L273 TraceCheckUtils]: 20: Hoare triple {9421#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9422#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:56,568 INFO L273 TraceCheckUtils]: 21: Hoare triple {9422#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9423#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:56,569 INFO L273 TraceCheckUtils]: 22: Hoare triple {9423#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9424#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:56,570 INFO L273 TraceCheckUtils]: 23: Hoare triple {9424#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9425#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:56,571 INFO L273 TraceCheckUtils]: 24: Hoare triple {9425#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9426#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:56,572 INFO L273 TraceCheckUtils]: 25: Hoare triple {9426#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9427#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:56,573 INFO L273 TraceCheckUtils]: 26: Hoare triple {9427#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9428#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:56,574 INFO L273 TraceCheckUtils]: 27: Hoare triple {9428#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9429#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:56,575 INFO L273 TraceCheckUtils]: 28: Hoare triple {9429#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9430#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:56,576 INFO L273 TraceCheckUtils]: 29: Hoare triple {9430#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9431#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:56,577 INFO L273 TraceCheckUtils]: 30: Hoare triple {9431#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9432#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:56,578 INFO L273 TraceCheckUtils]: 31: Hoare triple {9432#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9433#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:56,579 INFO L273 TraceCheckUtils]: 32: Hoare triple {9433#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9434#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:56,580 INFO L273 TraceCheckUtils]: 33: Hoare triple {9434#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9435#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:56,581 INFO L273 TraceCheckUtils]: 34: Hoare triple {9435#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9436#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:56,582 INFO L273 TraceCheckUtils]: 35: Hoare triple {9436#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9437#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:56,583 INFO L273 TraceCheckUtils]: 36: Hoare triple {9437#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9438#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:56,584 INFO L273 TraceCheckUtils]: 37: Hoare triple {9438#(<= main_~i~0 31)} assume !(~i~0 < 100000); {9406#false} is VALID [2018-11-23 12:10:56,584 INFO L273 TraceCheckUtils]: 38: Hoare triple {9406#false} havoc ~x~0;~x~0 := 0; {9406#false} is VALID [2018-11-23 12:10:56,584 INFO L273 TraceCheckUtils]: 39: Hoare triple {9406#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {9406#false} is VALID [2018-11-23 12:10:56,584 INFO L256 TraceCheckUtils]: 40: Hoare triple {9406#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {9406#false} is VALID [2018-11-23 12:10:56,584 INFO L273 TraceCheckUtils]: 41: Hoare triple {9406#false} ~cond := #in~cond; {9406#false} is VALID [2018-11-23 12:10:56,585 INFO L273 TraceCheckUtils]: 42: Hoare triple {9406#false} assume 0 == ~cond; {9406#false} is VALID [2018-11-23 12:10:56,585 INFO L273 TraceCheckUtils]: 43: Hoare triple {9406#false} assume !false; {9406#false} is VALID [2018-11-23 12:10:56,588 INFO L134 CoverageAnalysis]: Checked inductivity of 496 backedges. 0 proven. 496 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:56,588 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:56,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 32 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 32 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:56,600 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:10:56,654 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:56,668 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:56,669 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:56,826 INFO L256 TraceCheckUtils]: 0: Hoare triple {9405#true} call ULTIMATE.init(); {9405#true} is VALID [2018-11-23 12:10:56,826 INFO L273 TraceCheckUtils]: 1: Hoare triple {9405#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {9405#true} is VALID [2018-11-23 12:10:56,827 INFO L273 TraceCheckUtils]: 2: Hoare triple {9405#true} assume true; {9405#true} is VALID [2018-11-23 12:10:56,827 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {9405#true} {9405#true} #48#return; {9405#true} is VALID [2018-11-23 12:10:56,827 INFO L256 TraceCheckUtils]: 4: Hoare triple {9405#true} call #t~ret6 := main(); {9405#true} is VALID [2018-11-23 12:10:56,828 INFO L273 TraceCheckUtils]: 5: Hoare triple {9405#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {9457#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:56,829 INFO L273 TraceCheckUtils]: 6: Hoare triple {9457#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9408#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:56,830 INFO L273 TraceCheckUtils]: 7: Hoare triple {9408#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9409#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:56,830 INFO L273 TraceCheckUtils]: 8: Hoare triple {9409#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9410#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:56,831 INFO L273 TraceCheckUtils]: 9: Hoare triple {9410#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9411#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:56,832 INFO L273 TraceCheckUtils]: 10: Hoare triple {9411#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9412#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:56,832 INFO L273 TraceCheckUtils]: 11: Hoare triple {9412#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9413#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:56,833 INFO L273 TraceCheckUtils]: 12: Hoare triple {9413#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9414#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:56,834 INFO L273 TraceCheckUtils]: 13: Hoare triple {9414#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9415#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:56,835 INFO L273 TraceCheckUtils]: 14: Hoare triple {9415#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9416#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:56,836 INFO L273 TraceCheckUtils]: 15: Hoare triple {9416#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9417#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:56,837 INFO L273 TraceCheckUtils]: 16: Hoare triple {9417#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9418#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:56,838 INFO L273 TraceCheckUtils]: 17: Hoare triple {9418#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9419#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:56,839 INFO L273 TraceCheckUtils]: 18: Hoare triple {9419#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9420#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:56,840 INFO L273 TraceCheckUtils]: 19: Hoare triple {9420#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9421#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:56,841 INFO L273 TraceCheckUtils]: 20: Hoare triple {9421#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9422#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:56,842 INFO L273 TraceCheckUtils]: 21: Hoare triple {9422#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9423#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:56,843 INFO L273 TraceCheckUtils]: 22: Hoare triple {9423#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9424#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:56,844 INFO L273 TraceCheckUtils]: 23: Hoare triple {9424#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9425#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:56,845 INFO L273 TraceCheckUtils]: 24: Hoare triple {9425#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9426#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:56,846 INFO L273 TraceCheckUtils]: 25: Hoare triple {9426#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9427#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:56,847 INFO L273 TraceCheckUtils]: 26: Hoare triple {9427#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9428#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:56,848 INFO L273 TraceCheckUtils]: 27: Hoare triple {9428#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9429#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:56,849 INFO L273 TraceCheckUtils]: 28: Hoare triple {9429#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9430#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:56,850 INFO L273 TraceCheckUtils]: 29: Hoare triple {9430#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9431#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:56,852 INFO L273 TraceCheckUtils]: 30: Hoare triple {9431#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9432#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:56,853 INFO L273 TraceCheckUtils]: 31: Hoare triple {9432#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9433#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:56,854 INFO L273 TraceCheckUtils]: 32: Hoare triple {9433#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9434#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:56,855 INFO L273 TraceCheckUtils]: 33: Hoare triple {9434#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9435#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:56,855 INFO L273 TraceCheckUtils]: 34: Hoare triple {9435#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9436#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:56,856 INFO L273 TraceCheckUtils]: 35: Hoare triple {9436#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9437#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:56,857 INFO L273 TraceCheckUtils]: 36: Hoare triple {9437#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9438#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:56,858 INFO L273 TraceCheckUtils]: 37: Hoare triple {9438#(<= main_~i~0 31)} assume !(~i~0 < 100000); {9406#false} is VALID [2018-11-23 12:10:56,858 INFO L273 TraceCheckUtils]: 38: Hoare triple {9406#false} havoc ~x~0;~x~0 := 0; {9406#false} is VALID [2018-11-23 12:10:56,859 INFO L273 TraceCheckUtils]: 39: Hoare triple {9406#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {9406#false} is VALID [2018-11-23 12:10:56,859 INFO L256 TraceCheckUtils]: 40: Hoare triple {9406#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {9406#false} is VALID [2018-11-23 12:10:56,859 INFO L273 TraceCheckUtils]: 41: Hoare triple {9406#false} ~cond := #in~cond; {9406#false} is VALID [2018-11-23 12:10:56,859 INFO L273 TraceCheckUtils]: 42: Hoare triple {9406#false} assume 0 == ~cond; {9406#false} is VALID [2018-11-23 12:10:56,859 INFO L273 TraceCheckUtils]: 43: Hoare triple {9406#false} assume !false; {9406#false} is VALID [2018-11-23 12:10:56,861 INFO L134 CoverageAnalysis]: Checked inductivity of 496 backedges. 0 proven. 496 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:56,879 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:56,880 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [34, 34] total 35 [2018-11-23 12:10:56,880 INFO L78 Accepts]: Start accepts. Automaton has 35 states. Word has length 44 [2018-11-23 12:10:56,880 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:56,881 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 35 states. [2018-11-23 12:10:56,913 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 46 edges. 46 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:56,913 INFO L459 AbstractCegarLoop]: Interpolant automaton has 35 states [2018-11-23 12:10:56,914 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 35 interpolants. [2018-11-23 12:10:56,914 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=595, Invalid=595, Unknown=0, NotChecked=0, Total=1190 [2018-11-23 12:10:56,915 INFO L87 Difference]: Start difference. First operand 49 states and 50 transitions. Second operand 35 states. [2018-11-23 12:10:57,399 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:57,400 INFO L93 Difference]: Finished difference Result 61 states and 63 transitions. [2018-11-23 12:10:57,400 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 34 states. [2018-11-23 12:10:57,400 INFO L78 Accepts]: Start accepts. Automaton has 35 states. Word has length 44 [2018-11-23 12:10:57,400 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:57,400 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 35 states. [2018-11-23 12:10:57,402 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 34 states to 34 states and 63 transitions. [2018-11-23 12:10:57,402 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 35 states. [2018-11-23 12:10:57,403 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 34 states to 34 states and 63 transitions. [2018-11-23 12:10:57,403 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 34 states and 63 transitions. [2018-11-23 12:10:57,485 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 63 edges. 63 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:57,486 INFO L225 Difference]: With dead ends: 61 [2018-11-23 12:10:57,486 INFO L226 Difference]: Without dead ends: 50 [2018-11-23 12:10:57,487 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 77 GetRequests, 44 SyntacticMatches, 0 SemanticMatches, 33 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 60 ImplicationChecksByTransitivity, 0.4s TimeCoverageRelationStatistics Valid=595, Invalid=595, Unknown=0, NotChecked=0, Total=1190 [2018-11-23 12:10:57,487 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 50 states. [2018-11-23 12:10:57,512 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 50 to 50. [2018-11-23 12:10:57,512 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:57,512 INFO L82 GeneralOperation]: Start isEquivalent. First operand 50 states. Second operand 50 states. [2018-11-23 12:10:57,513 INFO L74 IsIncluded]: Start isIncluded. First operand 50 states. Second operand 50 states. [2018-11-23 12:10:57,513 INFO L87 Difference]: Start difference. First operand 50 states. Second operand 50 states. [2018-11-23 12:10:57,514 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:57,514 INFO L93 Difference]: Finished difference Result 50 states and 51 transitions. [2018-11-23 12:10:57,514 INFO L276 IsEmpty]: Start isEmpty. Operand 50 states and 51 transitions. [2018-11-23 12:10:57,514 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:57,515 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:57,515 INFO L74 IsIncluded]: Start isIncluded. First operand 50 states. Second operand 50 states. [2018-11-23 12:10:57,515 INFO L87 Difference]: Start difference. First operand 50 states. Second operand 50 states. [2018-11-23 12:10:57,516 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:57,516 INFO L93 Difference]: Finished difference Result 50 states and 51 transitions. [2018-11-23 12:10:57,516 INFO L276 IsEmpty]: Start isEmpty. Operand 50 states and 51 transitions. [2018-11-23 12:10:57,517 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:57,517 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:57,517 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:57,517 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:57,517 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 50 states. [2018-11-23 12:10:57,518 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 50 states to 50 states and 51 transitions. [2018-11-23 12:10:57,518 INFO L78 Accepts]: Start accepts. Automaton has 50 states and 51 transitions. Word has length 44 [2018-11-23 12:10:57,518 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:57,518 INFO L480 AbstractCegarLoop]: Abstraction has 50 states and 51 transitions. [2018-11-23 12:10:57,518 INFO L481 AbstractCegarLoop]: Interpolant automaton has 35 states. [2018-11-23 12:10:57,519 INFO L276 IsEmpty]: Start isEmpty. Operand 50 states and 51 transitions. [2018-11-23 12:10:57,519 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 46 [2018-11-23 12:10:57,519 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:57,519 INFO L402 BasicCegarLoop]: trace histogram [32, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:57,519 INFO L423 AbstractCegarLoop]: === Iteration 34 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:57,520 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:57,520 INFO L82 PathProgramCache]: Analyzing trace with hash 237083570, now seen corresponding path program 32 times [2018-11-23 12:10:57,520 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:57,520 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:57,521 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:57,521 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:10:57,521 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:57,553 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:58,200 INFO L256 TraceCheckUtils]: 0: Hoare triple {9865#true} call ULTIMATE.init(); {9865#true} is VALID [2018-11-23 12:10:58,200 INFO L273 TraceCheckUtils]: 1: Hoare triple {9865#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {9865#true} is VALID [2018-11-23 12:10:58,200 INFO L273 TraceCheckUtils]: 2: Hoare triple {9865#true} assume true; {9865#true} is VALID [2018-11-23 12:10:58,200 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {9865#true} {9865#true} #48#return; {9865#true} is VALID [2018-11-23 12:10:58,200 INFO L256 TraceCheckUtils]: 4: Hoare triple {9865#true} call #t~ret6 := main(); {9865#true} is VALID [2018-11-23 12:10:58,201 INFO L273 TraceCheckUtils]: 5: Hoare triple {9865#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {9867#(= main_~i~0 0)} is VALID [2018-11-23 12:10:58,201 INFO L273 TraceCheckUtils]: 6: Hoare triple {9867#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9868#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:58,202 INFO L273 TraceCheckUtils]: 7: Hoare triple {9868#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9869#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:58,203 INFO L273 TraceCheckUtils]: 8: Hoare triple {9869#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9870#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:58,205 INFO L273 TraceCheckUtils]: 9: Hoare triple {9870#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9871#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:58,206 INFO L273 TraceCheckUtils]: 10: Hoare triple {9871#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9872#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:58,207 INFO L273 TraceCheckUtils]: 11: Hoare triple {9872#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9873#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:58,208 INFO L273 TraceCheckUtils]: 12: Hoare triple {9873#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9874#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:58,209 INFO L273 TraceCheckUtils]: 13: Hoare triple {9874#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9875#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:58,210 INFO L273 TraceCheckUtils]: 14: Hoare triple {9875#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9876#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:58,211 INFO L273 TraceCheckUtils]: 15: Hoare triple {9876#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9877#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:58,212 INFO L273 TraceCheckUtils]: 16: Hoare triple {9877#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9878#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:58,213 INFO L273 TraceCheckUtils]: 17: Hoare triple {9878#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9879#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:58,214 INFO L273 TraceCheckUtils]: 18: Hoare triple {9879#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9880#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:58,215 INFO L273 TraceCheckUtils]: 19: Hoare triple {9880#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9881#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:58,216 INFO L273 TraceCheckUtils]: 20: Hoare triple {9881#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9882#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:58,217 INFO L273 TraceCheckUtils]: 21: Hoare triple {9882#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9883#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:58,219 INFO L273 TraceCheckUtils]: 22: Hoare triple {9883#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9884#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:58,220 INFO L273 TraceCheckUtils]: 23: Hoare triple {9884#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9885#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:58,221 INFO L273 TraceCheckUtils]: 24: Hoare triple {9885#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9886#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:58,222 INFO L273 TraceCheckUtils]: 25: Hoare triple {9886#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9887#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:58,223 INFO L273 TraceCheckUtils]: 26: Hoare triple {9887#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9888#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:58,224 INFO L273 TraceCheckUtils]: 27: Hoare triple {9888#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9889#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:58,225 INFO L273 TraceCheckUtils]: 28: Hoare triple {9889#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9890#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:58,226 INFO L273 TraceCheckUtils]: 29: Hoare triple {9890#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9891#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:58,227 INFO L273 TraceCheckUtils]: 30: Hoare triple {9891#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9892#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:58,228 INFO L273 TraceCheckUtils]: 31: Hoare triple {9892#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9893#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:58,229 INFO L273 TraceCheckUtils]: 32: Hoare triple {9893#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9894#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:58,230 INFO L273 TraceCheckUtils]: 33: Hoare triple {9894#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9895#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:58,231 INFO L273 TraceCheckUtils]: 34: Hoare triple {9895#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9896#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:58,233 INFO L273 TraceCheckUtils]: 35: Hoare triple {9896#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9897#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:58,234 INFO L273 TraceCheckUtils]: 36: Hoare triple {9897#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9898#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:58,235 INFO L273 TraceCheckUtils]: 37: Hoare triple {9898#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9899#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:58,235 INFO L273 TraceCheckUtils]: 38: Hoare triple {9899#(<= main_~i~0 32)} assume !(~i~0 < 100000); {9866#false} is VALID [2018-11-23 12:10:58,236 INFO L273 TraceCheckUtils]: 39: Hoare triple {9866#false} havoc ~x~0;~x~0 := 0; {9866#false} is VALID [2018-11-23 12:10:58,236 INFO L273 TraceCheckUtils]: 40: Hoare triple {9866#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {9866#false} is VALID [2018-11-23 12:10:58,236 INFO L256 TraceCheckUtils]: 41: Hoare triple {9866#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {9866#false} is VALID [2018-11-23 12:10:58,236 INFO L273 TraceCheckUtils]: 42: Hoare triple {9866#false} ~cond := #in~cond; {9866#false} is VALID [2018-11-23 12:10:58,236 INFO L273 TraceCheckUtils]: 43: Hoare triple {9866#false} assume 0 == ~cond; {9866#false} is VALID [2018-11-23 12:10:58,237 INFO L273 TraceCheckUtils]: 44: Hoare triple {9866#false} assume !false; {9866#false} is VALID [2018-11-23 12:10:58,239 INFO L134 CoverageAnalysis]: Checked inductivity of 528 backedges. 0 proven. 528 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:58,239 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:10:58,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 33 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 33 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:10:58,247 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:10:58,285 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:10:58,286 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:10:58,300 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:10:58,301 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:10:58,469 INFO L256 TraceCheckUtils]: 0: Hoare triple {9865#true} call ULTIMATE.init(); {9865#true} is VALID [2018-11-23 12:10:58,469 INFO L273 TraceCheckUtils]: 1: Hoare triple {9865#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {9865#true} is VALID [2018-11-23 12:10:58,469 INFO L273 TraceCheckUtils]: 2: Hoare triple {9865#true} assume true; {9865#true} is VALID [2018-11-23 12:10:58,469 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {9865#true} {9865#true} #48#return; {9865#true} is VALID [2018-11-23 12:10:58,470 INFO L256 TraceCheckUtils]: 4: Hoare triple {9865#true} call #t~ret6 := main(); {9865#true} is VALID [2018-11-23 12:10:58,471 INFO L273 TraceCheckUtils]: 5: Hoare triple {9865#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {9918#(<= main_~i~0 0)} is VALID [2018-11-23 12:10:58,472 INFO L273 TraceCheckUtils]: 6: Hoare triple {9918#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9868#(<= main_~i~0 1)} is VALID [2018-11-23 12:10:58,472 INFO L273 TraceCheckUtils]: 7: Hoare triple {9868#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9869#(<= main_~i~0 2)} is VALID [2018-11-23 12:10:58,473 INFO L273 TraceCheckUtils]: 8: Hoare triple {9869#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9870#(<= main_~i~0 3)} is VALID [2018-11-23 12:10:58,473 INFO L273 TraceCheckUtils]: 9: Hoare triple {9870#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9871#(<= main_~i~0 4)} is VALID [2018-11-23 12:10:58,474 INFO L273 TraceCheckUtils]: 10: Hoare triple {9871#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9872#(<= main_~i~0 5)} is VALID [2018-11-23 12:10:58,475 INFO L273 TraceCheckUtils]: 11: Hoare triple {9872#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9873#(<= main_~i~0 6)} is VALID [2018-11-23 12:10:58,476 INFO L273 TraceCheckUtils]: 12: Hoare triple {9873#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9874#(<= main_~i~0 7)} is VALID [2018-11-23 12:10:58,477 INFO L273 TraceCheckUtils]: 13: Hoare triple {9874#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9875#(<= main_~i~0 8)} is VALID [2018-11-23 12:10:58,478 INFO L273 TraceCheckUtils]: 14: Hoare triple {9875#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9876#(<= main_~i~0 9)} is VALID [2018-11-23 12:10:58,479 INFO L273 TraceCheckUtils]: 15: Hoare triple {9876#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9877#(<= main_~i~0 10)} is VALID [2018-11-23 12:10:58,480 INFO L273 TraceCheckUtils]: 16: Hoare triple {9877#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9878#(<= main_~i~0 11)} is VALID [2018-11-23 12:10:58,481 INFO L273 TraceCheckUtils]: 17: Hoare triple {9878#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9879#(<= main_~i~0 12)} is VALID [2018-11-23 12:10:58,482 INFO L273 TraceCheckUtils]: 18: Hoare triple {9879#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9880#(<= main_~i~0 13)} is VALID [2018-11-23 12:10:58,483 INFO L273 TraceCheckUtils]: 19: Hoare triple {9880#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9881#(<= main_~i~0 14)} is VALID [2018-11-23 12:10:58,484 INFO L273 TraceCheckUtils]: 20: Hoare triple {9881#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9882#(<= main_~i~0 15)} is VALID [2018-11-23 12:10:58,485 INFO L273 TraceCheckUtils]: 21: Hoare triple {9882#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9883#(<= main_~i~0 16)} is VALID [2018-11-23 12:10:58,486 INFO L273 TraceCheckUtils]: 22: Hoare triple {9883#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9884#(<= main_~i~0 17)} is VALID [2018-11-23 12:10:58,487 INFO L273 TraceCheckUtils]: 23: Hoare triple {9884#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9885#(<= main_~i~0 18)} is VALID [2018-11-23 12:10:58,488 INFO L273 TraceCheckUtils]: 24: Hoare triple {9885#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9886#(<= main_~i~0 19)} is VALID [2018-11-23 12:10:58,489 INFO L273 TraceCheckUtils]: 25: Hoare triple {9886#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9887#(<= main_~i~0 20)} is VALID [2018-11-23 12:10:58,490 INFO L273 TraceCheckUtils]: 26: Hoare triple {9887#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9888#(<= main_~i~0 21)} is VALID [2018-11-23 12:10:58,491 INFO L273 TraceCheckUtils]: 27: Hoare triple {9888#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9889#(<= main_~i~0 22)} is VALID [2018-11-23 12:10:58,492 INFO L273 TraceCheckUtils]: 28: Hoare triple {9889#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9890#(<= main_~i~0 23)} is VALID [2018-11-23 12:10:58,493 INFO L273 TraceCheckUtils]: 29: Hoare triple {9890#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9891#(<= main_~i~0 24)} is VALID [2018-11-23 12:10:58,494 INFO L273 TraceCheckUtils]: 30: Hoare triple {9891#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9892#(<= main_~i~0 25)} is VALID [2018-11-23 12:10:58,495 INFO L273 TraceCheckUtils]: 31: Hoare triple {9892#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9893#(<= main_~i~0 26)} is VALID [2018-11-23 12:10:58,496 INFO L273 TraceCheckUtils]: 32: Hoare triple {9893#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9894#(<= main_~i~0 27)} is VALID [2018-11-23 12:10:58,497 INFO L273 TraceCheckUtils]: 33: Hoare triple {9894#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9895#(<= main_~i~0 28)} is VALID [2018-11-23 12:10:58,498 INFO L273 TraceCheckUtils]: 34: Hoare triple {9895#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9896#(<= main_~i~0 29)} is VALID [2018-11-23 12:10:58,499 INFO L273 TraceCheckUtils]: 35: Hoare triple {9896#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9897#(<= main_~i~0 30)} is VALID [2018-11-23 12:10:58,500 INFO L273 TraceCheckUtils]: 36: Hoare triple {9897#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9898#(<= main_~i~0 31)} is VALID [2018-11-23 12:10:58,501 INFO L273 TraceCheckUtils]: 37: Hoare triple {9898#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {9899#(<= main_~i~0 32)} is VALID [2018-11-23 12:10:58,502 INFO L273 TraceCheckUtils]: 38: Hoare triple {9899#(<= main_~i~0 32)} assume !(~i~0 < 100000); {9866#false} is VALID [2018-11-23 12:10:58,502 INFO L273 TraceCheckUtils]: 39: Hoare triple {9866#false} havoc ~x~0;~x~0 := 0; {9866#false} is VALID [2018-11-23 12:10:58,503 INFO L273 TraceCheckUtils]: 40: Hoare triple {9866#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {9866#false} is VALID [2018-11-23 12:10:58,503 INFO L256 TraceCheckUtils]: 41: Hoare triple {9866#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {9866#false} is VALID [2018-11-23 12:10:58,503 INFO L273 TraceCheckUtils]: 42: Hoare triple {9866#false} ~cond := #in~cond; {9866#false} is VALID [2018-11-23 12:10:58,503 INFO L273 TraceCheckUtils]: 43: Hoare triple {9866#false} assume 0 == ~cond; {9866#false} is VALID [2018-11-23 12:10:58,503 INFO L273 TraceCheckUtils]: 44: Hoare triple {9866#false} assume !false; {9866#false} is VALID [2018-11-23 12:10:58,506 INFO L134 CoverageAnalysis]: Checked inductivity of 528 backedges. 0 proven. 528 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:10:58,524 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:10:58,524 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [35, 35] total 36 [2018-11-23 12:10:58,525 INFO L78 Accepts]: Start accepts. Automaton has 36 states. Word has length 45 [2018-11-23 12:10:58,525 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:10:58,525 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 36 states. [2018-11-23 12:10:58,558 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:10:58,558 INFO L459 AbstractCegarLoop]: Interpolant automaton has 36 states [2018-11-23 12:10:58,559 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 36 interpolants. [2018-11-23 12:10:58,559 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=630, Invalid=630, Unknown=0, NotChecked=0, Total=1260 [2018-11-23 12:10:58,560 INFO L87 Difference]: Start difference. First operand 50 states and 51 transitions. Second operand 36 states. [2018-11-23 12:10:59,049 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:59,050 INFO L93 Difference]: Finished difference Result 62 states and 64 transitions. [2018-11-23 12:10:59,050 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 35 states. [2018-11-23 12:10:59,050 INFO L78 Accepts]: Start accepts. Automaton has 36 states. Word has length 45 [2018-11-23 12:10:59,050 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:10:59,050 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 36 states. [2018-11-23 12:10:59,051 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 35 states to 35 states and 64 transitions. [2018-11-23 12:10:59,052 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 36 states. [2018-11-23 12:10:59,052 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 35 states to 35 states and 64 transitions. [2018-11-23 12:10:59,052 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 35 states and 64 transitions. [2018-11-23 12:10:59,102 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 64 edges. 64 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:10:59,103 INFO L225 Difference]: With dead ends: 62 [2018-11-23 12:10:59,103 INFO L226 Difference]: Without dead ends: 51 [2018-11-23 12:10:59,104 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 79 GetRequests, 45 SyntacticMatches, 0 SemanticMatches, 34 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 62 ImplicationChecksByTransitivity, 0.5s TimeCoverageRelationStatistics Valid=630, Invalid=630, Unknown=0, NotChecked=0, Total=1260 [2018-11-23 12:10:59,104 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 51 states. [2018-11-23 12:10:59,134 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 51 to 51. [2018-11-23 12:10:59,135 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:10:59,135 INFO L82 GeneralOperation]: Start isEquivalent. First operand 51 states. Second operand 51 states. [2018-11-23 12:10:59,135 INFO L74 IsIncluded]: Start isIncluded. First operand 51 states. Second operand 51 states. [2018-11-23 12:10:59,135 INFO L87 Difference]: Start difference. First operand 51 states. Second operand 51 states. [2018-11-23 12:10:59,136 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:59,136 INFO L93 Difference]: Finished difference Result 51 states and 52 transitions. [2018-11-23 12:10:59,136 INFO L276 IsEmpty]: Start isEmpty. Operand 51 states and 52 transitions. [2018-11-23 12:10:59,136 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:59,136 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:59,136 INFO L74 IsIncluded]: Start isIncluded. First operand 51 states. Second operand 51 states. [2018-11-23 12:10:59,136 INFO L87 Difference]: Start difference. First operand 51 states. Second operand 51 states. [2018-11-23 12:10:59,137 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:10:59,137 INFO L93 Difference]: Finished difference Result 51 states and 52 transitions. [2018-11-23 12:10:59,137 INFO L276 IsEmpty]: Start isEmpty. Operand 51 states and 52 transitions. [2018-11-23 12:10:59,137 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:10:59,137 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:10:59,138 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:10:59,138 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:10:59,138 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 51 states. [2018-11-23 12:10:59,138 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 51 states to 51 states and 52 transitions. [2018-11-23 12:10:59,138 INFO L78 Accepts]: Start accepts. Automaton has 51 states and 52 transitions. Word has length 45 [2018-11-23 12:10:59,138 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:10:59,139 INFO L480 AbstractCegarLoop]: Abstraction has 51 states and 52 transitions. [2018-11-23 12:10:59,139 INFO L481 AbstractCegarLoop]: Interpolant automaton has 36 states. [2018-11-23 12:10:59,139 INFO L276 IsEmpty]: Start isEmpty. Operand 51 states and 52 transitions. [2018-11-23 12:10:59,139 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 47 [2018-11-23 12:10:59,139 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:10:59,139 INFO L402 BasicCegarLoop]: trace histogram [33, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:10:59,139 INFO L423 AbstractCegarLoop]: === Iteration 35 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:10:59,139 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:10:59,140 INFO L82 PathProgramCache]: Analyzing trace with hash 963544686, now seen corresponding path program 33 times [2018-11-23 12:10:59,140 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:10:59,140 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:10:59,140 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:59,140 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:10:59,140 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:10:59,174 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:00,613 INFO L256 TraceCheckUtils]: 0: Hoare triple {10335#true} call ULTIMATE.init(); {10335#true} is VALID [2018-11-23 12:11:00,613 INFO L273 TraceCheckUtils]: 1: Hoare triple {10335#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {10335#true} is VALID [2018-11-23 12:11:00,613 INFO L273 TraceCheckUtils]: 2: Hoare triple {10335#true} assume true; {10335#true} is VALID [2018-11-23 12:11:00,613 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {10335#true} {10335#true} #48#return; {10335#true} is VALID [2018-11-23 12:11:00,614 INFO L256 TraceCheckUtils]: 4: Hoare triple {10335#true} call #t~ret6 := main(); {10335#true} is VALID [2018-11-23 12:11:00,614 INFO L273 TraceCheckUtils]: 5: Hoare triple {10335#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {10337#(= main_~i~0 0)} is VALID [2018-11-23 12:11:00,615 INFO L273 TraceCheckUtils]: 6: Hoare triple {10337#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10338#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:00,616 INFO L273 TraceCheckUtils]: 7: Hoare triple {10338#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10339#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:00,617 INFO L273 TraceCheckUtils]: 8: Hoare triple {10339#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10340#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:00,618 INFO L273 TraceCheckUtils]: 9: Hoare triple {10340#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10341#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:00,619 INFO L273 TraceCheckUtils]: 10: Hoare triple {10341#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10342#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:00,620 INFO L273 TraceCheckUtils]: 11: Hoare triple {10342#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10343#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:00,621 INFO L273 TraceCheckUtils]: 12: Hoare triple {10343#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10344#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:00,622 INFO L273 TraceCheckUtils]: 13: Hoare triple {10344#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10345#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:00,624 INFO L273 TraceCheckUtils]: 14: Hoare triple {10345#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10346#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:00,625 INFO L273 TraceCheckUtils]: 15: Hoare triple {10346#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10347#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:00,626 INFO L273 TraceCheckUtils]: 16: Hoare triple {10347#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10348#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:00,627 INFO L273 TraceCheckUtils]: 17: Hoare triple {10348#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10349#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:00,628 INFO L273 TraceCheckUtils]: 18: Hoare triple {10349#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10350#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:00,629 INFO L273 TraceCheckUtils]: 19: Hoare triple {10350#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10351#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:00,630 INFO L273 TraceCheckUtils]: 20: Hoare triple {10351#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10352#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:00,631 INFO L273 TraceCheckUtils]: 21: Hoare triple {10352#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10353#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:00,632 INFO L273 TraceCheckUtils]: 22: Hoare triple {10353#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10354#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:00,633 INFO L273 TraceCheckUtils]: 23: Hoare triple {10354#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10355#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:00,634 INFO L273 TraceCheckUtils]: 24: Hoare triple {10355#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10356#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:00,635 INFO L273 TraceCheckUtils]: 25: Hoare triple {10356#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10357#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:00,636 INFO L273 TraceCheckUtils]: 26: Hoare triple {10357#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10358#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:00,637 INFO L273 TraceCheckUtils]: 27: Hoare triple {10358#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10359#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:00,638 INFO L273 TraceCheckUtils]: 28: Hoare triple {10359#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10360#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:00,639 INFO L273 TraceCheckUtils]: 29: Hoare triple {10360#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10361#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:00,640 INFO L273 TraceCheckUtils]: 30: Hoare triple {10361#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10362#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:00,641 INFO L273 TraceCheckUtils]: 31: Hoare triple {10362#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10363#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:00,642 INFO L273 TraceCheckUtils]: 32: Hoare triple {10363#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10364#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:00,643 INFO L273 TraceCheckUtils]: 33: Hoare triple {10364#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10365#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:00,644 INFO L273 TraceCheckUtils]: 34: Hoare triple {10365#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10366#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:00,645 INFO L273 TraceCheckUtils]: 35: Hoare triple {10366#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10367#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:00,646 INFO L273 TraceCheckUtils]: 36: Hoare triple {10367#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10368#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:00,655 INFO L273 TraceCheckUtils]: 37: Hoare triple {10368#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10369#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:00,656 INFO L273 TraceCheckUtils]: 38: Hoare triple {10369#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10370#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:00,657 INFO L273 TraceCheckUtils]: 39: Hoare triple {10370#(<= main_~i~0 33)} assume !(~i~0 < 100000); {10336#false} is VALID [2018-11-23 12:11:00,657 INFO L273 TraceCheckUtils]: 40: Hoare triple {10336#false} havoc ~x~0;~x~0 := 0; {10336#false} is VALID [2018-11-23 12:11:00,657 INFO L273 TraceCheckUtils]: 41: Hoare triple {10336#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {10336#false} is VALID [2018-11-23 12:11:00,657 INFO L256 TraceCheckUtils]: 42: Hoare triple {10336#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {10336#false} is VALID [2018-11-23 12:11:00,657 INFO L273 TraceCheckUtils]: 43: Hoare triple {10336#false} ~cond := #in~cond; {10336#false} is VALID [2018-11-23 12:11:00,657 INFO L273 TraceCheckUtils]: 44: Hoare triple {10336#false} assume 0 == ~cond; {10336#false} is VALID [2018-11-23 12:11:00,657 INFO L273 TraceCheckUtils]: 45: Hoare triple {10336#false} assume !false; {10336#false} is VALID [2018-11-23 12:11:00,659 INFO L134 CoverageAnalysis]: Checked inductivity of 561 backedges. 0 proven. 561 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:11:00,659 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:11:00,659 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 34 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 34 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:11:00,668 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:11:26,101 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 18 check-sat command(s) [2018-11-23 12:11:26,101 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:11:26,126 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:26,127 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:11:26,323 INFO L256 TraceCheckUtils]: 0: Hoare triple {10335#true} call ULTIMATE.init(); {10335#true} is VALID [2018-11-23 12:11:26,323 INFO L273 TraceCheckUtils]: 1: Hoare triple {10335#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {10335#true} is VALID [2018-11-23 12:11:26,324 INFO L273 TraceCheckUtils]: 2: Hoare triple {10335#true} assume true; {10335#true} is VALID [2018-11-23 12:11:26,324 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {10335#true} {10335#true} #48#return; {10335#true} is VALID [2018-11-23 12:11:26,324 INFO L256 TraceCheckUtils]: 4: Hoare triple {10335#true} call #t~ret6 := main(); {10335#true} is VALID [2018-11-23 12:11:26,325 INFO L273 TraceCheckUtils]: 5: Hoare triple {10335#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {10389#(<= main_~i~0 0)} is VALID [2018-11-23 12:11:26,326 INFO L273 TraceCheckUtils]: 6: Hoare triple {10389#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10338#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:26,327 INFO L273 TraceCheckUtils]: 7: Hoare triple {10338#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10339#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:26,327 INFO L273 TraceCheckUtils]: 8: Hoare triple {10339#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10340#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:26,328 INFO L273 TraceCheckUtils]: 9: Hoare triple {10340#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10341#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:26,329 INFO L273 TraceCheckUtils]: 10: Hoare triple {10341#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10342#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:26,330 INFO L273 TraceCheckUtils]: 11: Hoare triple {10342#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10343#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:26,331 INFO L273 TraceCheckUtils]: 12: Hoare triple {10343#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10344#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:26,332 INFO L273 TraceCheckUtils]: 13: Hoare triple {10344#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10345#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:26,333 INFO L273 TraceCheckUtils]: 14: Hoare triple {10345#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10346#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:26,334 INFO L273 TraceCheckUtils]: 15: Hoare triple {10346#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10347#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:26,335 INFO L273 TraceCheckUtils]: 16: Hoare triple {10347#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10348#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:26,336 INFO L273 TraceCheckUtils]: 17: Hoare triple {10348#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10349#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:26,337 INFO L273 TraceCheckUtils]: 18: Hoare triple {10349#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10350#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:26,338 INFO L273 TraceCheckUtils]: 19: Hoare triple {10350#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10351#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:26,339 INFO L273 TraceCheckUtils]: 20: Hoare triple {10351#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10352#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:26,340 INFO L273 TraceCheckUtils]: 21: Hoare triple {10352#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10353#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:26,342 INFO L273 TraceCheckUtils]: 22: Hoare triple {10353#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10354#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:26,343 INFO L273 TraceCheckUtils]: 23: Hoare triple {10354#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10355#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:26,344 INFO L273 TraceCheckUtils]: 24: Hoare triple {10355#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10356#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:26,345 INFO L273 TraceCheckUtils]: 25: Hoare triple {10356#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10357#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:26,346 INFO L273 TraceCheckUtils]: 26: Hoare triple {10357#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10358#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:26,347 INFO L273 TraceCheckUtils]: 27: Hoare triple {10358#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10359#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:26,348 INFO L273 TraceCheckUtils]: 28: Hoare triple {10359#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10360#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:26,349 INFO L273 TraceCheckUtils]: 29: Hoare triple {10360#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10361#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:26,350 INFO L273 TraceCheckUtils]: 30: Hoare triple {10361#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10362#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:26,351 INFO L273 TraceCheckUtils]: 31: Hoare triple {10362#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10363#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:26,352 INFO L273 TraceCheckUtils]: 32: Hoare triple {10363#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10364#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:26,353 INFO L273 TraceCheckUtils]: 33: Hoare triple {10364#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10365#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:26,355 INFO L273 TraceCheckUtils]: 34: Hoare triple {10365#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10366#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:26,356 INFO L273 TraceCheckUtils]: 35: Hoare triple {10366#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10367#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:26,357 INFO L273 TraceCheckUtils]: 36: Hoare triple {10367#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10368#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:26,358 INFO L273 TraceCheckUtils]: 37: Hoare triple {10368#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10369#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:26,359 INFO L273 TraceCheckUtils]: 38: Hoare triple {10369#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10370#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:26,360 INFO L273 TraceCheckUtils]: 39: Hoare triple {10370#(<= main_~i~0 33)} assume !(~i~0 < 100000); {10336#false} is VALID [2018-11-23 12:11:26,360 INFO L273 TraceCheckUtils]: 40: Hoare triple {10336#false} havoc ~x~0;~x~0 := 0; {10336#false} is VALID [2018-11-23 12:11:26,360 INFO L273 TraceCheckUtils]: 41: Hoare triple {10336#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {10336#false} is VALID [2018-11-23 12:11:26,360 INFO L256 TraceCheckUtils]: 42: Hoare triple {10336#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {10336#false} is VALID [2018-11-23 12:11:26,360 INFO L273 TraceCheckUtils]: 43: Hoare triple {10336#false} ~cond := #in~cond; {10336#false} is VALID [2018-11-23 12:11:26,361 INFO L273 TraceCheckUtils]: 44: Hoare triple {10336#false} assume 0 == ~cond; {10336#false} is VALID [2018-11-23 12:11:26,361 INFO L273 TraceCheckUtils]: 45: Hoare triple {10336#false} assume !false; {10336#false} is VALID [2018-11-23 12:11:26,363 INFO L134 CoverageAnalysis]: Checked inductivity of 561 backedges. 0 proven. 561 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:11:26,389 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:11:26,389 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [36, 36] total 37 [2018-11-23 12:11:26,389 INFO L78 Accepts]: Start accepts. Automaton has 37 states. Word has length 46 [2018-11-23 12:11:26,389 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:11:26,389 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 37 states. [2018-11-23 12:11:26,426 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:11:26,426 INFO L459 AbstractCegarLoop]: Interpolant automaton has 37 states [2018-11-23 12:11:26,427 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 37 interpolants. [2018-11-23 12:11:26,428 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=666, Invalid=666, Unknown=0, NotChecked=0, Total=1332 [2018-11-23 12:11:26,428 INFO L87 Difference]: Start difference. First operand 51 states and 52 transitions. Second operand 37 states. [2018-11-23 12:11:26,648 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:26,648 INFO L93 Difference]: Finished difference Result 63 states and 65 transitions. [2018-11-23 12:11:26,649 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 36 states. [2018-11-23 12:11:26,649 INFO L78 Accepts]: Start accepts. Automaton has 37 states. Word has length 46 [2018-11-23 12:11:26,649 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:11:26,649 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 37 states. [2018-11-23 12:11:26,650 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 36 states to 36 states and 65 transitions. [2018-11-23 12:11:26,650 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 37 states. [2018-11-23 12:11:26,651 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 36 states to 36 states and 65 transitions. [2018-11-23 12:11:26,651 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 36 states and 65 transitions. [2018-11-23 12:11:26,704 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:11:26,705 INFO L225 Difference]: With dead ends: 63 [2018-11-23 12:11:26,705 INFO L226 Difference]: Without dead ends: 52 [2018-11-23 12:11:26,707 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 81 GetRequests, 46 SyntacticMatches, 0 SemanticMatches, 35 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 64 ImplicationChecksByTransitivity, 1.1s TimeCoverageRelationStatistics Valid=666, Invalid=666, Unknown=0, NotChecked=0, Total=1332 [2018-11-23 12:11:26,707 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 52 states. [2018-11-23 12:11:26,733 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 52 to 52. [2018-11-23 12:11:26,733 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:11:26,733 INFO L82 GeneralOperation]: Start isEquivalent. First operand 52 states. Second operand 52 states. [2018-11-23 12:11:26,733 INFO L74 IsIncluded]: Start isIncluded. First operand 52 states. Second operand 52 states. [2018-11-23 12:11:26,733 INFO L87 Difference]: Start difference. First operand 52 states. Second operand 52 states. [2018-11-23 12:11:26,734 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:26,734 INFO L93 Difference]: Finished difference Result 52 states and 53 transitions. [2018-11-23 12:11:26,734 INFO L276 IsEmpty]: Start isEmpty. Operand 52 states and 53 transitions. [2018-11-23 12:11:26,734 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:26,734 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:26,734 INFO L74 IsIncluded]: Start isIncluded. First operand 52 states. Second operand 52 states. [2018-11-23 12:11:26,734 INFO L87 Difference]: Start difference. First operand 52 states. Second operand 52 states. [2018-11-23 12:11:26,735 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:26,735 INFO L93 Difference]: Finished difference Result 52 states and 53 transitions. [2018-11-23 12:11:26,735 INFO L276 IsEmpty]: Start isEmpty. Operand 52 states and 53 transitions. [2018-11-23 12:11:26,735 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:26,736 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:26,736 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:11:26,736 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:11:26,736 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 52 states. [2018-11-23 12:11:26,737 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 52 states to 52 states and 53 transitions. [2018-11-23 12:11:26,737 INFO L78 Accepts]: Start accepts. Automaton has 52 states and 53 transitions. Word has length 46 [2018-11-23 12:11:26,737 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:11:26,737 INFO L480 AbstractCegarLoop]: Abstraction has 52 states and 53 transitions. [2018-11-23 12:11:26,737 INFO L481 AbstractCegarLoop]: Interpolant automaton has 37 states. [2018-11-23 12:11:26,737 INFO L276 IsEmpty]: Start isEmpty. Operand 52 states and 53 transitions. [2018-11-23 12:11:26,738 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 48 [2018-11-23 12:11:26,738 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:11:26,738 INFO L402 BasicCegarLoop]: trace histogram [34, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:11:26,738 INFO L423 AbstractCegarLoop]: === Iteration 36 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:11:26,738 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:11:26,738 INFO L82 PathProgramCache]: Analyzing trace with hash 2009002802, now seen corresponding path program 34 times [2018-11-23 12:11:26,739 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:11:26,739 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:11:26,739 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:26,739 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:11:26,740 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:26,775 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:27,596 INFO L256 TraceCheckUtils]: 0: Hoare triple {10815#true} call ULTIMATE.init(); {10815#true} is VALID [2018-11-23 12:11:27,596 INFO L273 TraceCheckUtils]: 1: Hoare triple {10815#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {10815#true} is VALID [2018-11-23 12:11:27,596 INFO L273 TraceCheckUtils]: 2: Hoare triple {10815#true} assume true; {10815#true} is VALID [2018-11-23 12:11:27,597 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {10815#true} {10815#true} #48#return; {10815#true} is VALID [2018-11-23 12:11:27,597 INFO L256 TraceCheckUtils]: 4: Hoare triple {10815#true} call #t~ret6 := main(); {10815#true} is VALID [2018-11-23 12:11:27,597 INFO L273 TraceCheckUtils]: 5: Hoare triple {10815#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {10817#(= main_~i~0 0)} is VALID [2018-11-23 12:11:27,599 INFO L273 TraceCheckUtils]: 6: Hoare triple {10817#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10818#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:27,600 INFO L273 TraceCheckUtils]: 7: Hoare triple {10818#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10819#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:27,601 INFO L273 TraceCheckUtils]: 8: Hoare triple {10819#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10820#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:27,602 INFO L273 TraceCheckUtils]: 9: Hoare triple {10820#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10821#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:27,603 INFO L273 TraceCheckUtils]: 10: Hoare triple {10821#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10822#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:27,604 INFO L273 TraceCheckUtils]: 11: Hoare triple {10822#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10823#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:27,605 INFO L273 TraceCheckUtils]: 12: Hoare triple {10823#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10824#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:27,606 INFO L273 TraceCheckUtils]: 13: Hoare triple {10824#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10825#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:27,607 INFO L273 TraceCheckUtils]: 14: Hoare triple {10825#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10826#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:27,608 INFO L273 TraceCheckUtils]: 15: Hoare triple {10826#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10827#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:27,610 INFO L273 TraceCheckUtils]: 16: Hoare triple {10827#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10828#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:27,611 INFO L273 TraceCheckUtils]: 17: Hoare triple {10828#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10829#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:27,612 INFO L273 TraceCheckUtils]: 18: Hoare triple {10829#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10830#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:27,613 INFO L273 TraceCheckUtils]: 19: Hoare triple {10830#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10831#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:27,614 INFO L273 TraceCheckUtils]: 20: Hoare triple {10831#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10832#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:27,615 INFO L273 TraceCheckUtils]: 21: Hoare triple {10832#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10833#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:27,616 INFO L273 TraceCheckUtils]: 22: Hoare triple {10833#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10834#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:27,617 INFO L273 TraceCheckUtils]: 23: Hoare triple {10834#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10835#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:27,618 INFO L273 TraceCheckUtils]: 24: Hoare triple {10835#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10836#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:27,619 INFO L273 TraceCheckUtils]: 25: Hoare triple {10836#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10837#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:27,620 INFO L273 TraceCheckUtils]: 26: Hoare triple {10837#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10838#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:27,621 INFO L273 TraceCheckUtils]: 27: Hoare triple {10838#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10839#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:27,622 INFO L273 TraceCheckUtils]: 28: Hoare triple {10839#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10840#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:27,624 INFO L273 TraceCheckUtils]: 29: Hoare triple {10840#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10841#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:27,625 INFO L273 TraceCheckUtils]: 30: Hoare triple {10841#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10842#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:27,626 INFO L273 TraceCheckUtils]: 31: Hoare triple {10842#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10843#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:27,627 INFO L273 TraceCheckUtils]: 32: Hoare triple {10843#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10844#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:27,628 INFO L273 TraceCheckUtils]: 33: Hoare triple {10844#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10845#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:27,629 INFO L273 TraceCheckUtils]: 34: Hoare triple {10845#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10846#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:27,630 INFO L273 TraceCheckUtils]: 35: Hoare triple {10846#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10847#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:27,631 INFO L273 TraceCheckUtils]: 36: Hoare triple {10847#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10848#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:27,632 INFO L273 TraceCheckUtils]: 37: Hoare triple {10848#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10849#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:27,633 INFO L273 TraceCheckUtils]: 38: Hoare triple {10849#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10850#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:27,634 INFO L273 TraceCheckUtils]: 39: Hoare triple {10850#(<= main_~i~0 33)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10851#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:27,635 INFO L273 TraceCheckUtils]: 40: Hoare triple {10851#(<= main_~i~0 34)} assume !(~i~0 < 100000); {10816#false} is VALID [2018-11-23 12:11:27,635 INFO L273 TraceCheckUtils]: 41: Hoare triple {10816#false} havoc ~x~0;~x~0 := 0; {10816#false} is VALID [2018-11-23 12:11:27,636 INFO L273 TraceCheckUtils]: 42: Hoare triple {10816#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {10816#false} is VALID [2018-11-23 12:11:27,636 INFO L256 TraceCheckUtils]: 43: Hoare triple {10816#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {10816#false} is VALID [2018-11-23 12:11:27,636 INFO L273 TraceCheckUtils]: 44: Hoare triple {10816#false} ~cond := #in~cond; {10816#false} is VALID [2018-11-23 12:11:27,636 INFO L273 TraceCheckUtils]: 45: Hoare triple {10816#false} assume 0 == ~cond; {10816#false} is VALID [2018-11-23 12:11:27,636 INFO L273 TraceCheckUtils]: 46: Hoare triple {10816#false} assume !false; {10816#false} is VALID [2018-11-23 12:11:27,639 INFO L134 CoverageAnalysis]: Checked inductivity of 595 backedges. 0 proven. 595 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:11:27,639 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:11:27,639 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 35 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 35 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:11:27,648 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:11:27,687 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:11:27,687 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:11:27,706 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:27,707 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:11:27,940 INFO L256 TraceCheckUtils]: 0: Hoare triple {10815#true} call ULTIMATE.init(); {10815#true} is VALID [2018-11-23 12:11:27,941 INFO L273 TraceCheckUtils]: 1: Hoare triple {10815#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {10815#true} is VALID [2018-11-23 12:11:27,941 INFO L273 TraceCheckUtils]: 2: Hoare triple {10815#true} assume true; {10815#true} is VALID [2018-11-23 12:11:27,941 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {10815#true} {10815#true} #48#return; {10815#true} is VALID [2018-11-23 12:11:27,942 INFO L256 TraceCheckUtils]: 4: Hoare triple {10815#true} call #t~ret6 := main(); {10815#true} is VALID [2018-11-23 12:11:27,943 INFO L273 TraceCheckUtils]: 5: Hoare triple {10815#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {10870#(<= main_~i~0 0)} is VALID [2018-11-23 12:11:27,944 INFO L273 TraceCheckUtils]: 6: Hoare triple {10870#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10818#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:27,945 INFO L273 TraceCheckUtils]: 7: Hoare triple {10818#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10819#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:27,946 INFO L273 TraceCheckUtils]: 8: Hoare triple {10819#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10820#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:27,946 INFO L273 TraceCheckUtils]: 9: Hoare triple {10820#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10821#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:27,948 INFO L273 TraceCheckUtils]: 10: Hoare triple {10821#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10822#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:27,949 INFO L273 TraceCheckUtils]: 11: Hoare triple {10822#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10823#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:27,950 INFO L273 TraceCheckUtils]: 12: Hoare triple {10823#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10824#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:27,951 INFO L273 TraceCheckUtils]: 13: Hoare triple {10824#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10825#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:27,953 INFO L273 TraceCheckUtils]: 14: Hoare triple {10825#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10826#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:27,954 INFO L273 TraceCheckUtils]: 15: Hoare triple {10826#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10827#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:27,955 INFO L273 TraceCheckUtils]: 16: Hoare triple {10827#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10828#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:27,956 INFO L273 TraceCheckUtils]: 17: Hoare triple {10828#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10829#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:27,957 INFO L273 TraceCheckUtils]: 18: Hoare triple {10829#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10830#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:27,959 INFO L273 TraceCheckUtils]: 19: Hoare triple {10830#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10831#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:27,960 INFO L273 TraceCheckUtils]: 20: Hoare triple {10831#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10832#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:27,961 INFO L273 TraceCheckUtils]: 21: Hoare triple {10832#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10833#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:27,962 INFO L273 TraceCheckUtils]: 22: Hoare triple {10833#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10834#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:27,964 INFO L273 TraceCheckUtils]: 23: Hoare triple {10834#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10835#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:27,965 INFO L273 TraceCheckUtils]: 24: Hoare triple {10835#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10836#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:27,966 INFO L273 TraceCheckUtils]: 25: Hoare triple {10836#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10837#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:27,967 INFO L273 TraceCheckUtils]: 26: Hoare triple {10837#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10838#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:27,969 INFO L273 TraceCheckUtils]: 27: Hoare triple {10838#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10839#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:27,970 INFO L273 TraceCheckUtils]: 28: Hoare triple {10839#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10840#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:27,971 INFO L273 TraceCheckUtils]: 29: Hoare triple {10840#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10841#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:27,972 INFO L273 TraceCheckUtils]: 30: Hoare triple {10841#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10842#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:27,973 INFO L273 TraceCheckUtils]: 31: Hoare triple {10842#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10843#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:27,975 INFO L273 TraceCheckUtils]: 32: Hoare triple {10843#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10844#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:27,976 INFO L273 TraceCheckUtils]: 33: Hoare triple {10844#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10845#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:27,977 INFO L273 TraceCheckUtils]: 34: Hoare triple {10845#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10846#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:27,978 INFO L273 TraceCheckUtils]: 35: Hoare triple {10846#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10847#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:27,979 INFO L273 TraceCheckUtils]: 36: Hoare triple {10847#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10848#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:27,981 INFO L273 TraceCheckUtils]: 37: Hoare triple {10848#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10849#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:27,982 INFO L273 TraceCheckUtils]: 38: Hoare triple {10849#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10850#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:27,983 INFO L273 TraceCheckUtils]: 39: Hoare triple {10850#(<= main_~i~0 33)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {10851#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:27,984 INFO L273 TraceCheckUtils]: 40: Hoare triple {10851#(<= main_~i~0 34)} assume !(~i~0 < 100000); {10816#false} is VALID [2018-11-23 12:11:27,984 INFO L273 TraceCheckUtils]: 41: Hoare triple {10816#false} havoc ~x~0;~x~0 := 0; {10816#false} is VALID [2018-11-23 12:11:27,984 INFO L273 TraceCheckUtils]: 42: Hoare triple {10816#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {10816#false} is VALID [2018-11-23 12:11:27,985 INFO L256 TraceCheckUtils]: 43: Hoare triple {10816#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {10816#false} is VALID [2018-11-23 12:11:27,985 INFO L273 TraceCheckUtils]: 44: Hoare triple {10816#false} ~cond := #in~cond; {10816#false} is VALID [2018-11-23 12:11:27,985 INFO L273 TraceCheckUtils]: 45: Hoare triple {10816#false} assume 0 == ~cond; {10816#false} is VALID [2018-11-23 12:11:27,985 INFO L273 TraceCheckUtils]: 46: Hoare triple {10816#false} assume !false; {10816#false} is VALID [2018-11-23 12:11:27,990 INFO L134 CoverageAnalysis]: Checked inductivity of 595 backedges. 0 proven. 595 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:11:28,009 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:11:28,009 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [37, 37] total 38 [2018-11-23 12:11:28,010 INFO L78 Accepts]: Start accepts. Automaton has 38 states. Word has length 47 [2018-11-23 12:11:28,010 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:11:28,010 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 38 states. [2018-11-23 12:11:28,052 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 49 edges. 49 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:28,052 INFO L459 AbstractCegarLoop]: Interpolant automaton has 38 states [2018-11-23 12:11:28,052 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 38 interpolants. [2018-11-23 12:11:28,053 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=703, Invalid=703, Unknown=0, NotChecked=0, Total=1406 [2018-11-23 12:11:28,053 INFO L87 Difference]: Start difference. First operand 52 states and 53 transitions. Second operand 38 states. [2018-11-23 12:11:28,819 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:28,819 INFO L93 Difference]: Finished difference Result 64 states and 66 transitions. [2018-11-23 12:11:28,819 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 37 states. [2018-11-23 12:11:28,820 INFO L78 Accepts]: Start accepts. Automaton has 38 states. Word has length 47 [2018-11-23 12:11:28,820 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:11:28,820 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 38 states. [2018-11-23 12:11:28,821 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 37 states to 37 states and 66 transitions. [2018-11-23 12:11:28,822 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 38 states. [2018-11-23 12:11:28,822 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 37 states to 37 states and 66 transitions. [2018-11-23 12:11:28,822 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 37 states and 66 transitions. [2018-11-23 12:11:28,966 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:11:28,967 INFO L225 Difference]: With dead ends: 64 [2018-11-23 12:11:28,967 INFO L226 Difference]: Without dead ends: 53 [2018-11-23 12:11:28,968 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 83 GetRequests, 47 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:11:28,968 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 53 states. [2018-11-23 12:11:28,999 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 53 to 53. [2018-11-23 12:11:29,000 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:11:29,000 INFO L82 GeneralOperation]: Start isEquivalent. First operand 53 states. Second operand 53 states. [2018-11-23 12:11:29,000 INFO L74 IsIncluded]: Start isIncluded. First operand 53 states. Second operand 53 states. [2018-11-23 12:11:29,000 INFO L87 Difference]: Start difference. First operand 53 states. Second operand 53 states. [2018-11-23 12:11:29,002 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:29,002 INFO L93 Difference]: Finished difference Result 53 states and 54 transitions. [2018-11-23 12:11:29,002 INFO L276 IsEmpty]: Start isEmpty. Operand 53 states and 54 transitions. [2018-11-23 12:11:29,002 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:29,002 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:29,003 INFO L74 IsIncluded]: Start isIncluded. First operand 53 states. Second operand 53 states. [2018-11-23 12:11:29,003 INFO L87 Difference]: Start difference. First operand 53 states. Second operand 53 states. [2018-11-23 12:11:29,003 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:29,004 INFO L93 Difference]: Finished difference Result 53 states and 54 transitions. [2018-11-23 12:11:29,004 INFO L276 IsEmpty]: Start isEmpty. Operand 53 states and 54 transitions. [2018-11-23 12:11:29,004 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:29,004 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:29,004 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:11:29,004 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:11:29,005 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 53 states. [2018-11-23 12:11:29,005 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 53 states to 53 states and 54 transitions. [2018-11-23 12:11:29,006 INFO L78 Accepts]: Start accepts. Automaton has 53 states and 54 transitions. Word has length 47 [2018-11-23 12:11:29,006 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:11:29,006 INFO L480 AbstractCegarLoop]: Abstraction has 53 states and 54 transitions. [2018-11-23 12:11:29,006 INFO L481 AbstractCegarLoop]: Interpolant automaton has 38 states. [2018-11-23 12:11:29,006 INFO L276 IsEmpty]: Start isEmpty. Operand 53 states and 54 transitions. [2018-11-23 12:11:29,007 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 49 [2018-11-23 12:11:29,007 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:11:29,007 INFO L402 BasicCegarLoop]: trace histogram [35, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:11:29,007 INFO L423 AbstractCegarLoop]: === Iteration 37 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:11:29,007 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:11:29,007 INFO L82 PathProgramCache]: Analyzing trace with hash 58466030, now seen corresponding path program 35 times [2018-11-23 12:11:29,007 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:11:29,008 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:11:29,008 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:29,008 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:11:29,008 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:29,045 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:29,715 INFO L256 TraceCheckUtils]: 0: Hoare triple {11305#true} call ULTIMATE.init(); {11305#true} is VALID [2018-11-23 12:11:29,715 INFO L273 TraceCheckUtils]: 1: Hoare triple {11305#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {11305#true} is VALID [2018-11-23 12:11:29,715 INFO L273 TraceCheckUtils]: 2: Hoare triple {11305#true} assume true; {11305#true} is VALID [2018-11-23 12:11:29,715 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {11305#true} {11305#true} #48#return; {11305#true} is VALID [2018-11-23 12:11:29,715 INFO L256 TraceCheckUtils]: 4: Hoare triple {11305#true} call #t~ret6 := main(); {11305#true} is VALID [2018-11-23 12:11:29,716 INFO L273 TraceCheckUtils]: 5: Hoare triple {11305#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {11307#(= main_~i~0 0)} is VALID [2018-11-23 12:11:29,717 INFO L273 TraceCheckUtils]: 6: Hoare triple {11307#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11308#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:29,717 INFO L273 TraceCheckUtils]: 7: Hoare triple {11308#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11309#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:29,718 INFO L273 TraceCheckUtils]: 8: Hoare triple {11309#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11310#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:29,719 INFO L273 TraceCheckUtils]: 9: Hoare triple {11310#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11311#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:29,720 INFO L273 TraceCheckUtils]: 10: Hoare triple {11311#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11312#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:29,721 INFO L273 TraceCheckUtils]: 11: Hoare triple {11312#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11313#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:29,722 INFO L273 TraceCheckUtils]: 12: Hoare triple {11313#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11314#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:29,723 INFO L273 TraceCheckUtils]: 13: Hoare triple {11314#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11315#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:29,724 INFO L273 TraceCheckUtils]: 14: Hoare triple {11315#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11316#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:29,726 INFO L273 TraceCheckUtils]: 15: Hoare triple {11316#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11317#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:29,727 INFO L273 TraceCheckUtils]: 16: Hoare triple {11317#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11318#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:29,728 INFO L273 TraceCheckUtils]: 17: Hoare triple {11318#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11319#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:29,729 INFO L273 TraceCheckUtils]: 18: Hoare triple {11319#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11320#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:29,730 INFO L273 TraceCheckUtils]: 19: Hoare triple {11320#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11321#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:29,731 INFO L273 TraceCheckUtils]: 20: Hoare triple {11321#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11322#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:29,732 INFO L273 TraceCheckUtils]: 21: Hoare triple {11322#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11323#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:29,733 INFO L273 TraceCheckUtils]: 22: Hoare triple {11323#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11324#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:29,734 INFO L273 TraceCheckUtils]: 23: Hoare triple {11324#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11325#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:29,735 INFO L273 TraceCheckUtils]: 24: Hoare triple {11325#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11326#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:29,736 INFO L273 TraceCheckUtils]: 25: Hoare triple {11326#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11327#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:29,737 INFO L273 TraceCheckUtils]: 26: Hoare triple {11327#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11328#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:29,738 INFO L273 TraceCheckUtils]: 27: Hoare triple {11328#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11329#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:29,740 INFO L273 TraceCheckUtils]: 28: Hoare triple {11329#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11330#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:29,741 INFO L273 TraceCheckUtils]: 29: Hoare triple {11330#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11331#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:29,742 INFO L273 TraceCheckUtils]: 30: Hoare triple {11331#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11332#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:29,743 INFO L273 TraceCheckUtils]: 31: Hoare triple {11332#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11333#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:29,744 INFO L273 TraceCheckUtils]: 32: Hoare triple {11333#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11334#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:29,745 INFO L273 TraceCheckUtils]: 33: Hoare triple {11334#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11335#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:29,746 INFO L273 TraceCheckUtils]: 34: Hoare triple {11335#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11336#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:29,747 INFO L273 TraceCheckUtils]: 35: Hoare triple {11336#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11337#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:29,748 INFO L273 TraceCheckUtils]: 36: Hoare triple {11337#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11338#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:29,749 INFO L273 TraceCheckUtils]: 37: Hoare triple {11338#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11339#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:29,750 INFO L273 TraceCheckUtils]: 38: Hoare triple {11339#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11340#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:29,751 INFO L273 TraceCheckUtils]: 39: Hoare triple {11340#(<= main_~i~0 33)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11341#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:29,752 INFO L273 TraceCheckUtils]: 40: Hoare triple {11341#(<= main_~i~0 34)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11342#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:29,753 INFO L273 TraceCheckUtils]: 41: Hoare triple {11342#(<= main_~i~0 35)} assume !(~i~0 < 100000); {11306#false} is VALID [2018-11-23 12:11:29,753 INFO L273 TraceCheckUtils]: 42: Hoare triple {11306#false} havoc ~x~0;~x~0 := 0; {11306#false} is VALID [2018-11-23 12:11:29,754 INFO L273 TraceCheckUtils]: 43: Hoare triple {11306#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {11306#false} is VALID [2018-11-23 12:11:29,754 INFO L256 TraceCheckUtils]: 44: Hoare triple {11306#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {11306#false} is VALID [2018-11-23 12:11:29,754 INFO L273 TraceCheckUtils]: 45: Hoare triple {11306#false} ~cond := #in~cond; {11306#false} is VALID [2018-11-23 12:11:29,754 INFO L273 TraceCheckUtils]: 46: Hoare triple {11306#false} assume 0 == ~cond; {11306#false} is VALID [2018-11-23 12:11:29,754 INFO L273 TraceCheckUtils]: 47: Hoare triple {11306#false} assume !false; {11306#false} is VALID [2018-11-23 12:11:29,757 INFO L134 CoverageAnalysis]: Checked inductivity of 630 backedges. 0 proven. 630 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:11:29,757 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:11:29,757 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 36 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 36 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:11:29,766 INFO L103 rtionOrderModulation]: Keeping assertion order INSIDE_LOOP_FIRST1 [2018-11-23 12:11:30,804 INFO L249 tOrderPrioritization]: Assert order INSIDE_LOOP_FIRST1 issued 19 check-sat command(s) [2018-11-23 12:11:30,804 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:11:30,841 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:30,842 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:11:32,270 INFO L256 TraceCheckUtils]: 0: Hoare triple {11305#true} call ULTIMATE.init(); {11305#true} is VALID [2018-11-23 12:11:32,270 INFO L273 TraceCheckUtils]: 1: Hoare triple {11305#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {11305#true} is VALID [2018-11-23 12:11:32,270 INFO L273 TraceCheckUtils]: 2: Hoare triple {11305#true} assume true; {11305#true} is VALID [2018-11-23 12:11:32,271 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {11305#true} {11305#true} #48#return; {11305#true} is VALID [2018-11-23 12:11:32,271 INFO L256 TraceCheckUtils]: 4: Hoare triple {11305#true} call #t~ret6 := main(); {11305#true} is VALID [2018-11-23 12:11:32,272 INFO L273 TraceCheckUtils]: 5: Hoare triple {11305#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {11361#(<= main_~i~0 0)} is VALID [2018-11-23 12:11:32,273 INFO L273 TraceCheckUtils]: 6: Hoare triple {11361#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11308#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:32,274 INFO L273 TraceCheckUtils]: 7: Hoare triple {11308#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11309#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:32,274 INFO L273 TraceCheckUtils]: 8: Hoare triple {11309#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11310#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:32,275 INFO L273 TraceCheckUtils]: 9: Hoare triple {11310#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11311#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:32,276 INFO L273 TraceCheckUtils]: 10: Hoare triple {11311#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11312#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:32,276 INFO L273 TraceCheckUtils]: 11: Hoare triple {11312#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11313#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:32,278 INFO L273 TraceCheckUtils]: 12: Hoare triple {11313#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11314#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:32,279 INFO L273 TraceCheckUtils]: 13: Hoare triple {11314#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11315#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:32,280 INFO L273 TraceCheckUtils]: 14: Hoare triple {11315#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11316#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:32,281 INFO L273 TraceCheckUtils]: 15: Hoare triple {11316#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11317#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:32,282 INFO L273 TraceCheckUtils]: 16: Hoare triple {11317#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11318#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:32,283 INFO L273 TraceCheckUtils]: 17: Hoare triple {11318#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11319#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:32,284 INFO L273 TraceCheckUtils]: 18: Hoare triple {11319#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11320#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:32,285 INFO L273 TraceCheckUtils]: 19: Hoare triple {11320#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11321#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:32,286 INFO L273 TraceCheckUtils]: 20: Hoare triple {11321#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11322#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:32,287 INFO L273 TraceCheckUtils]: 21: Hoare triple {11322#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11323#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:32,288 INFO L273 TraceCheckUtils]: 22: Hoare triple {11323#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11324#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:32,290 INFO L273 TraceCheckUtils]: 23: Hoare triple {11324#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11325#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:32,291 INFO L273 TraceCheckUtils]: 24: Hoare triple {11325#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11326#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:32,292 INFO L273 TraceCheckUtils]: 25: Hoare triple {11326#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11327#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:32,293 INFO L273 TraceCheckUtils]: 26: Hoare triple {11327#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11328#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:32,294 INFO L273 TraceCheckUtils]: 27: Hoare triple {11328#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11329#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:32,295 INFO L273 TraceCheckUtils]: 28: Hoare triple {11329#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11330#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:32,296 INFO L273 TraceCheckUtils]: 29: Hoare triple {11330#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11331#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:32,297 INFO L273 TraceCheckUtils]: 30: Hoare triple {11331#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11332#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:32,298 INFO L273 TraceCheckUtils]: 31: Hoare triple {11332#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11333#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:32,299 INFO L273 TraceCheckUtils]: 32: Hoare triple {11333#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11334#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:32,300 INFO L273 TraceCheckUtils]: 33: Hoare triple {11334#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11335#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:32,301 INFO L273 TraceCheckUtils]: 34: Hoare triple {11335#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11336#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:32,302 INFO L273 TraceCheckUtils]: 35: Hoare triple {11336#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11337#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:32,304 INFO L273 TraceCheckUtils]: 36: Hoare triple {11337#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11338#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:32,305 INFO L273 TraceCheckUtils]: 37: Hoare triple {11338#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11339#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:32,306 INFO L273 TraceCheckUtils]: 38: Hoare triple {11339#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11340#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:32,307 INFO L273 TraceCheckUtils]: 39: Hoare triple {11340#(<= main_~i~0 33)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11341#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:32,308 INFO L273 TraceCheckUtils]: 40: Hoare triple {11341#(<= main_~i~0 34)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11342#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:32,309 INFO L273 TraceCheckUtils]: 41: Hoare triple {11342#(<= main_~i~0 35)} assume !(~i~0 < 100000); {11306#false} is VALID [2018-11-23 12:11:32,309 INFO L273 TraceCheckUtils]: 42: Hoare triple {11306#false} havoc ~x~0;~x~0 := 0; {11306#false} is VALID [2018-11-23 12:11:32,309 INFO L273 TraceCheckUtils]: 43: Hoare triple {11306#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {11306#false} is VALID [2018-11-23 12:11:32,309 INFO L256 TraceCheckUtils]: 44: Hoare triple {11306#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {11306#false} is VALID [2018-11-23 12:11:32,309 INFO L273 TraceCheckUtils]: 45: Hoare triple {11306#false} ~cond := #in~cond; {11306#false} is VALID [2018-11-23 12:11:32,310 INFO L273 TraceCheckUtils]: 46: Hoare triple {11306#false} assume 0 == ~cond; {11306#false} is VALID [2018-11-23 12:11:32,310 INFO L273 TraceCheckUtils]: 47: Hoare triple {11306#false} assume !false; {11306#false} is VALID [2018-11-23 12:11:32,312 INFO L134 CoverageAnalysis]: Checked inductivity of 630 backedges. 0 proven. 630 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:11:32,332 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:11:32,332 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [38, 38] total 39 [2018-11-23 12:11:32,333 INFO L78 Accepts]: Start accepts. Automaton has 39 states. Word has length 48 [2018-11-23 12:11:32,333 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:11:32,333 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 39 states. [2018-11-23 12:11:32,371 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 50 edges. 50 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:32,371 INFO L459 AbstractCegarLoop]: Interpolant automaton has 39 states [2018-11-23 12:11:32,371 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 39 interpolants. [2018-11-23 12:11:32,372 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=741, Invalid=741, Unknown=0, NotChecked=0, Total=1482 [2018-11-23 12:11:32,372 INFO L87 Difference]: Start difference. First operand 53 states and 54 transitions. Second operand 39 states. [2018-11-23 12:11:32,697 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:32,698 INFO L93 Difference]: Finished difference Result 65 states and 67 transitions. [2018-11-23 12:11:32,698 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 38 states. [2018-11-23 12:11:32,698 INFO L78 Accepts]: Start accepts. Automaton has 39 states. Word has length 48 [2018-11-23 12:11:32,698 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:11:32,698 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 39 states. [2018-11-23 12:11:32,699 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 38 states to 38 states and 67 transitions. [2018-11-23 12:11:32,699 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 39 states. [2018-11-23 12:11:32,700 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 38 states to 38 states and 67 transitions. [2018-11-23 12:11:32,700 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 38 states and 67 transitions. [2018-11-23 12:11:32,756 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:11:32,758 INFO L225 Difference]: With dead ends: 65 [2018-11-23 12:11:32,758 INFO L226 Difference]: Without dead ends: 54 [2018-11-23 12:11:32,759 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 85 GetRequests, 48 SyntacticMatches, 0 SemanticMatches, 37 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 68 ImplicationChecksByTransitivity, 0.7s TimeCoverageRelationStatistics Valid=741, Invalid=741, Unknown=0, NotChecked=0, Total=1482 [2018-11-23 12:11:32,760 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 54 states. [2018-11-23 12:11:32,793 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 54 to 54. [2018-11-23 12:11:32,794 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:11:32,794 INFO L82 GeneralOperation]: Start isEquivalent. First operand 54 states. Second operand 54 states. [2018-11-23 12:11:32,794 INFO L74 IsIncluded]: Start isIncluded. First operand 54 states. Second operand 54 states. [2018-11-23 12:11:32,794 INFO L87 Difference]: Start difference. First operand 54 states. Second operand 54 states. [2018-11-23 12:11:32,795 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:32,795 INFO L93 Difference]: Finished difference Result 54 states and 55 transitions. [2018-11-23 12:11:32,795 INFO L276 IsEmpty]: Start isEmpty. Operand 54 states and 55 transitions. [2018-11-23 12:11:32,795 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:32,795 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:32,795 INFO L74 IsIncluded]: Start isIncluded. First operand 54 states. Second operand 54 states. [2018-11-23 12:11:32,795 INFO L87 Difference]: Start difference. First operand 54 states. Second operand 54 states. [2018-11-23 12:11:32,796 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:32,796 INFO L93 Difference]: Finished difference Result 54 states and 55 transitions. [2018-11-23 12:11:32,797 INFO L276 IsEmpty]: Start isEmpty. Operand 54 states and 55 transitions. [2018-11-23 12:11:32,797 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:32,797 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:32,797 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:11:32,797 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:11:32,797 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 54 states. [2018-11-23 12:11:32,798 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 54 states to 54 states and 55 transitions. [2018-11-23 12:11:32,798 INFO L78 Accepts]: Start accepts. Automaton has 54 states and 55 transitions. Word has length 48 [2018-11-23 12:11:32,799 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:11:32,799 INFO L480 AbstractCegarLoop]: Abstraction has 54 states and 55 transitions. [2018-11-23 12:11:32,799 INFO L481 AbstractCegarLoop]: Interpolant automaton has 39 states. [2018-11-23 12:11:32,799 INFO L276 IsEmpty]: Start isEmpty. Operand 54 states and 55 transitions. [2018-11-23 12:11:32,799 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 50 [2018-11-23 12:11:32,799 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:11:32,799 INFO L402 BasicCegarLoop]: trace histogram [36, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:11:32,800 INFO L423 AbstractCegarLoop]: === Iteration 38 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:11:32,800 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:11:32,800 INFO L82 PathProgramCache]: Analyzing trace with hash -278631758, now seen corresponding path program 36 times [2018-11-23 12:11:32,800 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:11:32,800 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:11:32,801 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:32,801 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:11:32,801 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:32,842 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:33,782 INFO L256 TraceCheckUtils]: 0: Hoare triple {11805#true} call ULTIMATE.init(); {11805#true} is VALID [2018-11-23 12:11:33,782 INFO L273 TraceCheckUtils]: 1: Hoare triple {11805#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {11805#true} is VALID [2018-11-23 12:11:33,782 INFO L273 TraceCheckUtils]: 2: Hoare triple {11805#true} assume true; {11805#true} is VALID [2018-11-23 12:11:33,782 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {11805#true} {11805#true} #48#return; {11805#true} is VALID [2018-11-23 12:11:33,783 INFO L256 TraceCheckUtils]: 4: Hoare triple {11805#true} call #t~ret6 := main(); {11805#true} is VALID [2018-11-23 12:11:33,783 INFO L273 TraceCheckUtils]: 5: Hoare triple {11805#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {11807#(= main_~i~0 0)} is VALID [2018-11-23 12:11:33,784 INFO L273 TraceCheckUtils]: 6: Hoare triple {11807#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11808#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:33,785 INFO L273 TraceCheckUtils]: 7: Hoare triple {11808#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11809#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:33,786 INFO L273 TraceCheckUtils]: 8: Hoare triple {11809#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11810#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:33,786 INFO L273 TraceCheckUtils]: 9: Hoare triple {11810#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11811#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:33,787 INFO L273 TraceCheckUtils]: 10: Hoare triple {11811#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11812#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:33,789 INFO L273 TraceCheckUtils]: 11: Hoare triple {11812#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11813#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:33,790 INFO L273 TraceCheckUtils]: 12: Hoare triple {11813#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11814#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:33,791 INFO L273 TraceCheckUtils]: 13: Hoare triple {11814#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11815#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:33,792 INFO L273 TraceCheckUtils]: 14: Hoare triple {11815#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11816#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:33,793 INFO L273 TraceCheckUtils]: 15: Hoare triple {11816#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11817#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:33,794 INFO L273 TraceCheckUtils]: 16: Hoare triple {11817#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11818#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:33,795 INFO L273 TraceCheckUtils]: 17: Hoare triple {11818#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11819#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:33,796 INFO L273 TraceCheckUtils]: 18: Hoare triple {11819#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11820#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:33,797 INFO L273 TraceCheckUtils]: 19: Hoare triple {11820#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11821#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:33,798 INFO L273 TraceCheckUtils]: 20: Hoare triple {11821#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11822#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:33,799 INFO L273 TraceCheckUtils]: 21: Hoare triple {11822#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11823#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:33,800 INFO L273 TraceCheckUtils]: 22: Hoare triple {11823#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11824#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:33,802 INFO L273 TraceCheckUtils]: 23: Hoare triple {11824#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11825#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:33,803 INFO L273 TraceCheckUtils]: 24: Hoare triple {11825#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11826#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:33,804 INFO L273 TraceCheckUtils]: 25: Hoare triple {11826#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11827#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:33,805 INFO L273 TraceCheckUtils]: 26: Hoare triple {11827#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11828#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:33,806 INFO L273 TraceCheckUtils]: 27: Hoare triple {11828#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11829#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:33,807 INFO L273 TraceCheckUtils]: 28: Hoare triple {11829#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11830#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:33,808 INFO L273 TraceCheckUtils]: 29: Hoare triple {11830#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11831#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:33,809 INFO L273 TraceCheckUtils]: 30: Hoare triple {11831#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11832#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:33,810 INFO L273 TraceCheckUtils]: 31: Hoare triple {11832#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11833#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:33,811 INFO L273 TraceCheckUtils]: 32: Hoare triple {11833#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11834#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:33,812 INFO L273 TraceCheckUtils]: 33: Hoare triple {11834#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11835#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:33,813 INFO L273 TraceCheckUtils]: 34: Hoare triple {11835#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11836#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:33,815 INFO L273 TraceCheckUtils]: 35: Hoare triple {11836#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11837#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:33,816 INFO L273 TraceCheckUtils]: 36: Hoare triple {11837#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11838#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:33,817 INFO L273 TraceCheckUtils]: 37: Hoare triple {11838#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11839#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:33,818 INFO L273 TraceCheckUtils]: 38: Hoare triple {11839#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11840#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:33,819 INFO L273 TraceCheckUtils]: 39: Hoare triple {11840#(<= main_~i~0 33)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11841#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:33,820 INFO L273 TraceCheckUtils]: 40: Hoare triple {11841#(<= main_~i~0 34)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11842#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:33,821 INFO L273 TraceCheckUtils]: 41: Hoare triple {11842#(<= main_~i~0 35)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11843#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:33,822 INFO L273 TraceCheckUtils]: 42: Hoare triple {11843#(<= main_~i~0 36)} assume !(~i~0 < 100000); {11806#false} is VALID [2018-11-23 12:11:33,822 INFO L273 TraceCheckUtils]: 43: Hoare triple {11806#false} havoc ~x~0;~x~0 := 0; {11806#false} is VALID [2018-11-23 12:11:33,822 INFO L273 TraceCheckUtils]: 44: Hoare triple {11806#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {11806#false} is VALID [2018-11-23 12:11:33,822 INFO L256 TraceCheckUtils]: 45: Hoare triple {11806#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {11806#false} is VALID [2018-11-23 12:11:33,823 INFO L273 TraceCheckUtils]: 46: Hoare triple {11806#false} ~cond := #in~cond; {11806#false} is VALID [2018-11-23 12:11:33,823 INFO L273 TraceCheckUtils]: 47: Hoare triple {11806#false} assume 0 == ~cond; {11806#false} is VALID [2018-11-23 12:11:33,823 INFO L273 TraceCheckUtils]: 48: Hoare triple {11806#false} assume !false; {11806#false} is VALID [2018-11-23 12:11:33,826 INFO L134 CoverageAnalysis]: Checked inductivity of 666 backedges. 0 proven. 666 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:11:33,826 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:11:33,826 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 37 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 37 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:11:33,835 INFO L103 rtionOrderModulation]: Keeping assertion order MIX_INSIDE_OUTSIDE [2018-11-23 12:11:53,651 INFO L249 tOrderPrioritization]: Assert order MIX_INSIDE_OUTSIDE issued 19 check-sat command(s) [2018-11-23 12:11:53,651 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:11:53,682 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:53,683 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:11:54,376 INFO L256 TraceCheckUtils]: 0: Hoare triple {11805#true} call ULTIMATE.init(); {11805#true} is VALID [2018-11-23 12:11:54,377 INFO L273 TraceCheckUtils]: 1: Hoare triple {11805#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {11805#true} is VALID [2018-11-23 12:11:54,377 INFO L273 TraceCheckUtils]: 2: Hoare triple {11805#true} assume true; {11805#true} is VALID [2018-11-23 12:11:54,377 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {11805#true} {11805#true} #48#return; {11805#true} is VALID [2018-11-23 12:11:54,377 INFO L256 TraceCheckUtils]: 4: Hoare triple {11805#true} call #t~ret6 := main(); {11805#true} is VALID [2018-11-23 12:11:54,378 INFO L273 TraceCheckUtils]: 5: Hoare triple {11805#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {11862#(<= main_~i~0 0)} is VALID [2018-11-23 12:11:54,378 INFO L273 TraceCheckUtils]: 6: Hoare triple {11862#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11808#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:54,379 INFO L273 TraceCheckUtils]: 7: Hoare triple {11808#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11809#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:54,380 INFO L273 TraceCheckUtils]: 8: Hoare triple {11809#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11810#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:54,380 INFO L273 TraceCheckUtils]: 9: Hoare triple {11810#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11811#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:54,381 INFO L273 TraceCheckUtils]: 10: Hoare triple {11811#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11812#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:54,382 INFO L273 TraceCheckUtils]: 11: Hoare triple {11812#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11813#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:54,383 INFO L273 TraceCheckUtils]: 12: Hoare triple {11813#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11814#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:54,384 INFO L273 TraceCheckUtils]: 13: Hoare triple {11814#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11815#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:54,385 INFO L273 TraceCheckUtils]: 14: Hoare triple {11815#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11816#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:54,386 INFO L273 TraceCheckUtils]: 15: Hoare triple {11816#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11817#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:54,387 INFO L273 TraceCheckUtils]: 16: Hoare triple {11817#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11818#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:54,389 INFO L273 TraceCheckUtils]: 17: Hoare triple {11818#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11819#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:54,390 INFO L273 TraceCheckUtils]: 18: Hoare triple {11819#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11820#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:54,391 INFO L273 TraceCheckUtils]: 19: Hoare triple {11820#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11821#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:54,392 INFO L273 TraceCheckUtils]: 20: Hoare triple {11821#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11822#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:54,393 INFO L273 TraceCheckUtils]: 21: Hoare triple {11822#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11823#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:54,394 INFO L273 TraceCheckUtils]: 22: Hoare triple {11823#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11824#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:54,395 INFO L273 TraceCheckUtils]: 23: Hoare triple {11824#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11825#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:54,396 INFO L273 TraceCheckUtils]: 24: Hoare triple {11825#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11826#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:54,397 INFO L273 TraceCheckUtils]: 25: Hoare triple {11826#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11827#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:54,398 INFO L273 TraceCheckUtils]: 26: Hoare triple {11827#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11828#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:54,399 INFO L273 TraceCheckUtils]: 27: Hoare triple {11828#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11829#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:54,400 INFO L273 TraceCheckUtils]: 28: Hoare triple {11829#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11830#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:54,401 INFO L273 TraceCheckUtils]: 29: Hoare triple {11830#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11831#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:54,403 INFO L273 TraceCheckUtils]: 30: Hoare triple {11831#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11832#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:54,404 INFO L273 TraceCheckUtils]: 31: Hoare triple {11832#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11833#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:54,405 INFO L273 TraceCheckUtils]: 32: Hoare triple {11833#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11834#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:54,406 INFO L273 TraceCheckUtils]: 33: Hoare triple {11834#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11835#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:54,407 INFO L273 TraceCheckUtils]: 34: Hoare triple {11835#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11836#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:54,408 INFO L273 TraceCheckUtils]: 35: Hoare triple {11836#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11837#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:54,409 INFO L273 TraceCheckUtils]: 36: Hoare triple {11837#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11838#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:54,410 INFO L273 TraceCheckUtils]: 37: Hoare triple {11838#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11839#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:54,411 INFO L273 TraceCheckUtils]: 38: Hoare triple {11839#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11840#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:54,412 INFO L273 TraceCheckUtils]: 39: Hoare triple {11840#(<= main_~i~0 33)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11841#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:54,414 INFO L273 TraceCheckUtils]: 40: Hoare triple {11841#(<= main_~i~0 34)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11842#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:54,415 INFO L273 TraceCheckUtils]: 41: Hoare triple {11842#(<= main_~i~0 35)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {11843#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:54,415 INFO L273 TraceCheckUtils]: 42: Hoare triple {11843#(<= main_~i~0 36)} assume !(~i~0 < 100000); {11806#false} is VALID [2018-11-23 12:11:54,416 INFO L273 TraceCheckUtils]: 43: Hoare triple {11806#false} havoc ~x~0;~x~0 := 0; {11806#false} is VALID [2018-11-23 12:11:54,416 INFO L273 TraceCheckUtils]: 44: Hoare triple {11806#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {11806#false} is VALID [2018-11-23 12:11:54,416 INFO L256 TraceCheckUtils]: 45: Hoare triple {11806#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {11806#false} is VALID [2018-11-23 12:11:54,416 INFO L273 TraceCheckUtils]: 46: Hoare triple {11806#false} ~cond := #in~cond; {11806#false} is VALID [2018-11-23 12:11:54,416 INFO L273 TraceCheckUtils]: 47: Hoare triple {11806#false} assume 0 == ~cond; {11806#false} is VALID [2018-11-23 12:11:54,417 INFO L273 TraceCheckUtils]: 48: Hoare triple {11806#false} assume !false; {11806#false} is VALID [2018-11-23 12:11:54,419 INFO L134 CoverageAnalysis]: Checked inductivity of 666 backedges. 0 proven. 666 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:11:54,444 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:11:54,444 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [39, 39] total 40 [2018-11-23 12:11:54,444 INFO L78 Accepts]: Start accepts. Automaton has 40 states. Word has length 49 [2018-11-23 12:11:54,445 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:11:54,445 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 40 states. [2018-11-23 12:11:54,483 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 51 edges. 51 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:54,483 INFO L459 AbstractCegarLoop]: Interpolant automaton has 40 states [2018-11-23 12:11:54,483 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 40 interpolants. [2018-11-23 12:11:54,484 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=780, Invalid=780, Unknown=0, NotChecked=0, Total=1560 [2018-11-23 12:11:54,484 INFO L87 Difference]: Start difference. First operand 54 states and 55 transitions. Second operand 40 states. [2018-11-23 12:11:54,728 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:54,729 INFO L93 Difference]: Finished difference Result 66 states and 68 transitions. [2018-11-23 12:11:54,729 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 39 states. [2018-11-23 12:11:54,729 INFO L78 Accepts]: Start accepts. Automaton has 40 states. Word has length 49 [2018-11-23 12:11:54,729 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:11:54,729 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 40 states. [2018-11-23 12:11:54,730 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 39 states to 39 states and 68 transitions. [2018-11-23 12:11:54,730 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 40 states. [2018-11-23 12:11:54,731 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 39 states to 39 states and 68 transitions. [2018-11-23 12:11:54,731 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 39 states and 68 transitions. [2018-11-23 12:11:54,794 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 68 edges. 68 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:54,795 INFO L225 Difference]: With dead ends: 66 [2018-11-23 12:11:54,795 INFO L226 Difference]: Without dead ends: 55 [2018-11-23 12:11:54,797 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 87 GetRequests, 49 SyntacticMatches, 0 SemanticMatches, 38 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 70 ImplicationChecksByTransitivity, 0.7s TimeCoverageRelationStatistics Valid=780, Invalid=780, Unknown=0, NotChecked=0, Total=1560 [2018-11-23 12:11:54,797 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 55 states. [2018-11-23 12:11:54,823 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 55 to 55. [2018-11-23 12:11:54,823 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:11:54,823 INFO L82 GeneralOperation]: Start isEquivalent. First operand 55 states. Second operand 55 states. [2018-11-23 12:11:54,823 INFO L74 IsIncluded]: Start isIncluded. First operand 55 states. Second operand 55 states. [2018-11-23 12:11:54,823 INFO L87 Difference]: Start difference. First operand 55 states. Second operand 55 states. [2018-11-23 12:11:54,824 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:54,824 INFO L93 Difference]: Finished difference Result 55 states and 56 transitions. [2018-11-23 12:11:54,824 INFO L276 IsEmpty]: Start isEmpty. Operand 55 states and 56 transitions. [2018-11-23 12:11:54,825 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:54,825 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:54,825 INFO L74 IsIncluded]: Start isIncluded. First operand 55 states. Second operand 55 states. [2018-11-23 12:11:54,825 INFO L87 Difference]: Start difference. First operand 55 states. Second operand 55 states. [2018-11-23 12:11:54,825 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:54,826 INFO L93 Difference]: Finished difference Result 55 states and 56 transitions. [2018-11-23 12:11:54,826 INFO L276 IsEmpty]: Start isEmpty. Operand 55 states and 56 transitions. [2018-11-23 12:11:54,826 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:54,826 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:54,826 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:11:54,826 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:11:54,826 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 55 states. [2018-11-23 12:11:54,827 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 55 states to 55 states and 56 transitions. [2018-11-23 12:11:54,827 INFO L78 Accepts]: Start accepts. Automaton has 55 states and 56 transitions. Word has length 49 [2018-11-23 12:11:54,827 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:11:54,828 INFO L480 AbstractCegarLoop]: Abstraction has 55 states and 56 transitions. [2018-11-23 12:11:54,828 INFO L481 AbstractCegarLoop]: Interpolant automaton has 40 states. [2018-11-23 12:11:54,828 INFO L276 IsEmpty]: Start isEmpty. Operand 55 states and 56 transitions. [2018-11-23 12:11:54,828 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 51 [2018-11-23 12:11:54,828 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:11:54,828 INFO L402 BasicCegarLoop]: trace histogram [37, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:11:54,828 INFO L423 AbstractCegarLoop]: === Iteration 39 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:11:54,829 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:11:54,829 INFO L82 PathProgramCache]: Analyzing trace with hash -2138728594, now seen corresponding path program 37 times [2018-11-23 12:11:54,829 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:11:54,829 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:11:54,829 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:54,830 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:11:54,830 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:54,871 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:55,817 INFO L256 TraceCheckUtils]: 0: Hoare triple {12315#true} call ULTIMATE.init(); {12315#true} is VALID [2018-11-23 12:11:55,818 INFO L273 TraceCheckUtils]: 1: Hoare triple {12315#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {12315#true} is VALID [2018-11-23 12:11:55,818 INFO L273 TraceCheckUtils]: 2: Hoare triple {12315#true} assume true; {12315#true} is VALID [2018-11-23 12:11:55,818 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {12315#true} {12315#true} #48#return; {12315#true} is VALID [2018-11-23 12:11:55,818 INFO L256 TraceCheckUtils]: 4: Hoare triple {12315#true} call #t~ret6 := main(); {12315#true} is VALID [2018-11-23 12:11:55,819 INFO L273 TraceCheckUtils]: 5: Hoare triple {12315#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {12317#(= main_~i~0 0)} is VALID [2018-11-23 12:11:55,819 INFO L273 TraceCheckUtils]: 6: Hoare triple {12317#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12318#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:55,820 INFO L273 TraceCheckUtils]: 7: Hoare triple {12318#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12319#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:55,821 INFO L273 TraceCheckUtils]: 8: Hoare triple {12319#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12320#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:55,822 INFO L273 TraceCheckUtils]: 9: Hoare triple {12320#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12321#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:55,823 INFO L273 TraceCheckUtils]: 10: Hoare triple {12321#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12322#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:55,824 INFO L273 TraceCheckUtils]: 11: Hoare triple {12322#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12323#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:55,825 INFO L273 TraceCheckUtils]: 12: Hoare triple {12323#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12324#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:55,826 INFO L273 TraceCheckUtils]: 13: Hoare triple {12324#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12325#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:55,827 INFO L273 TraceCheckUtils]: 14: Hoare triple {12325#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12326#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:55,828 INFO L273 TraceCheckUtils]: 15: Hoare triple {12326#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12327#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:55,831 INFO L273 TraceCheckUtils]: 16: Hoare triple {12327#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12328#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:55,832 INFO L273 TraceCheckUtils]: 17: Hoare triple {12328#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12329#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:55,833 INFO L273 TraceCheckUtils]: 18: Hoare triple {12329#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12330#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:55,833 INFO L273 TraceCheckUtils]: 19: Hoare triple {12330#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12331#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:55,834 INFO L273 TraceCheckUtils]: 20: Hoare triple {12331#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12332#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:55,836 INFO L273 TraceCheckUtils]: 21: Hoare triple {12332#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12333#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:55,837 INFO L273 TraceCheckUtils]: 22: Hoare triple {12333#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12334#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:55,838 INFO L273 TraceCheckUtils]: 23: Hoare triple {12334#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12335#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:55,839 INFO L273 TraceCheckUtils]: 24: Hoare triple {12335#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12336#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:55,840 INFO L273 TraceCheckUtils]: 25: Hoare triple {12336#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12337#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:55,841 INFO L273 TraceCheckUtils]: 26: Hoare triple {12337#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12338#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:55,842 INFO L273 TraceCheckUtils]: 27: Hoare triple {12338#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12339#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:55,843 INFO L273 TraceCheckUtils]: 28: Hoare triple {12339#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12340#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:55,844 INFO L273 TraceCheckUtils]: 29: Hoare triple {12340#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12341#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:55,845 INFO L273 TraceCheckUtils]: 30: Hoare triple {12341#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12342#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:55,846 INFO L273 TraceCheckUtils]: 31: Hoare triple {12342#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12343#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:55,847 INFO L273 TraceCheckUtils]: 32: Hoare triple {12343#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12344#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:55,848 INFO L273 TraceCheckUtils]: 33: Hoare triple {12344#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12345#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:55,850 INFO L273 TraceCheckUtils]: 34: Hoare triple {12345#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12346#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:55,851 INFO L273 TraceCheckUtils]: 35: Hoare triple {12346#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12347#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:55,852 INFO L273 TraceCheckUtils]: 36: Hoare triple {12347#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12348#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:55,853 INFO L273 TraceCheckUtils]: 37: Hoare triple {12348#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12349#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:55,854 INFO L273 TraceCheckUtils]: 38: Hoare triple {12349#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12350#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:55,855 INFO L273 TraceCheckUtils]: 39: Hoare triple {12350#(<= main_~i~0 33)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12351#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:55,856 INFO L273 TraceCheckUtils]: 40: Hoare triple {12351#(<= main_~i~0 34)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12352#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:55,857 INFO L273 TraceCheckUtils]: 41: Hoare triple {12352#(<= main_~i~0 35)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12353#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:55,858 INFO L273 TraceCheckUtils]: 42: Hoare triple {12353#(<= main_~i~0 36)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12354#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:55,859 INFO L273 TraceCheckUtils]: 43: Hoare triple {12354#(<= main_~i~0 37)} assume !(~i~0 < 100000); {12316#false} is VALID [2018-11-23 12:11:55,859 INFO L273 TraceCheckUtils]: 44: Hoare triple {12316#false} havoc ~x~0;~x~0 := 0; {12316#false} is VALID [2018-11-23 12:11:55,859 INFO L273 TraceCheckUtils]: 45: Hoare triple {12316#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {12316#false} is VALID [2018-11-23 12:11:55,860 INFO L256 TraceCheckUtils]: 46: Hoare triple {12316#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {12316#false} is VALID [2018-11-23 12:11:55,860 INFO L273 TraceCheckUtils]: 47: Hoare triple {12316#false} ~cond := #in~cond; {12316#false} is VALID [2018-11-23 12:11:55,860 INFO L273 TraceCheckUtils]: 48: Hoare triple {12316#false} assume 0 == ~cond; {12316#false} is VALID [2018-11-23 12:11:55,860 INFO L273 TraceCheckUtils]: 49: Hoare triple {12316#false} assume !false; {12316#false} is VALID [2018-11-23 12:11:55,863 INFO L134 CoverageAnalysis]: Checked inductivity of 703 backedges. 0 proven. 703 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:11:55,863 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:11:55,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 38 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 38 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:11:55,873 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:11:55,920 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:55,940 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:55,941 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:11:56,306 INFO L256 TraceCheckUtils]: 0: Hoare triple {12315#true} call ULTIMATE.init(); {12315#true} is VALID [2018-11-23 12:11:56,306 INFO L273 TraceCheckUtils]: 1: Hoare triple {12315#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {12315#true} is VALID [2018-11-23 12:11:56,307 INFO L273 TraceCheckUtils]: 2: Hoare triple {12315#true} assume true; {12315#true} is VALID [2018-11-23 12:11:56,307 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {12315#true} {12315#true} #48#return; {12315#true} is VALID [2018-11-23 12:11:56,307 INFO L256 TraceCheckUtils]: 4: Hoare triple {12315#true} call #t~ret6 := main(); {12315#true} is VALID [2018-11-23 12:11:56,308 INFO L273 TraceCheckUtils]: 5: Hoare triple {12315#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {12373#(<= main_~i~0 0)} is VALID [2018-11-23 12:11:56,309 INFO L273 TraceCheckUtils]: 6: Hoare triple {12373#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12318#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:56,309 INFO L273 TraceCheckUtils]: 7: Hoare triple {12318#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12319#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:56,310 INFO L273 TraceCheckUtils]: 8: Hoare triple {12319#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12320#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:56,311 INFO L273 TraceCheckUtils]: 9: Hoare triple {12320#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12321#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:56,312 INFO L273 TraceCheckUtils]: 10: Hoare triple {12321#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12322#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:56,313 INFO L273 TraceCheckUtils]: 11: Hoare triple {12322#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12323#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:56,314 INFO L273 TraceCheckUtils]: 12: Hoare triple {12323#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12324#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:56,315 INFO L273 TraceCheckUtils]: 13: Hoare triple {12324#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12325#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:56,316 INFO L273 TraceCheckUtils]: 14: Hoare triple {12325#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12326#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:56,317 INFO L273 TraceCheckUtils]: 15: Hoare triple {12326#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12327#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:56,318 INFO L273 TraceCheckUtils]: 16: Hoare triple {12327#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12328#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:56,319 INFO L273 TraceCheckUtils]: 17: Hoare triple {12328#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12329#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:56,320 INFO L273 TraceCheckUtils]: 18: Hoare triple {12329#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12330#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:56,321 INFO L273 TraceCheckUtils]: 19: Hoare triple {12330#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12331#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:56,322 INFO L273 TraceCheckUtils]: 20: Hoare triple {12331#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12332#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:56,324 INFO L273 TraceCheckUtils]: 21: Hoare triple {12332#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12333#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:56,325 INFO L273 TraceCheckUtils]: 22: Hoare triple {12333#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12334#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:56,326 INFO L273 TraceCheckUtils]: 23: Hoare triple {12334#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12335#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:56,327 INFO L273 TraceCheckUtils]: 24: Hoare triple {12335#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12336#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:56,328 INFO L273 TraceCheckUtils]: 25: Hoare triple {12336#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12337#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:56,329 INFO L273 TraceCheckUtils]: 26: Hoare triple {12337#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12338#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:56,330 INFO L273 TraceCheckUtils]: 27: Hoare triple {12338#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12339#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:56,331 INFO L273 TraceCheckUtils]: 28: Hoare triple {12339#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12340#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:56,332 INFO L273 TraceCheckUtils]: 29: Hoare triple {12340#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12341#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:56,333 INFO L273 TraceCheckUtils]: 30: Hoare triple {12341#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12342#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:56,334 INFO L273 TraceCheckUtils]: 31: Hoare triple {12342#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12343#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:56,335 INFO L273 TraceCheckUtils]: 32: Hoare triple {12343#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12344#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:56,336 INFO L273 TraceCheckUtils]: 33: Hoare triple {12344#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12345#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:56,338 INFO L273 TraceCheckUtils]: 34: Hoare triple {12345#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12346#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:56,339 INFO L273 TraceCheckUtils]: 35: Hoare triple {12346#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12347#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:56,340 INFO L273 TraceCheckUtils]: 36: Hoare triple {12347#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12348#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:56,341 INFO L273 TraceCheckUtils]: 37: Hoare triple {12348#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12349#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:56,342 INFO L273 TraceCheckUtils]: 38: Hoare triple {12349#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12350#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:56,343 INFO L273 TraceCheckUtils]: 39: Hoare triple {12350#(<= main_~i~0 33)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12351#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:56,344 INFO L273 TraceCheckUtils]: 40: Hoare triple {12351#(<= main_~i~0 34)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12352#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:56,345 INFO L273 TraceCheckUtils]: 41: Hoare triple {12352#(<= main_~i~0 35)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12353#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:56,346 INFO L273 TraceCheckUtils]: 42: Hoare triple {12353#(<= main_~i~0 36)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12354#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:56,347 INFO L273 TraceCheckUtils]: 43: Hoare triple {12354#(<= main_~i~0 37)} assume !(~i~0 < 100000); {12316#false} is VALID [2018-11-23 12:11:56,347 INFO L273 TraceCheckUtils]: 44: Hoare triple {12316#false} havoc ~x~0;~x~0 := 0; {12316#false} is VALID [2018-11-23 12:11:56,347 INFO L273 TraceCheckUtils]: 45: Hoare triple {12316#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {12316#false} is VALID [2018-11-23 12:11:56,347 INFO L256 TraceCheckUtils]: 46: Hoare triple {12316#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {12316#false} is VALID [2018-11-23 12:11:56,348 INFO L273 TraceCheckUtils]: 47: Hoare triple {12316#false} ~cond := #in~cond; {12316#false} is VALID [2018-11-23 12:11:56,348 INFO L273 TraceCheckUtils]: 48: Hoare triple {12316#false} assume 0 == ~cond; {12316#false} is VALID [2018-11-23 12:11:56,348 INFO L273 TraceCheckUtils]: 49: Hoare triple {12316#false} assume !false; {12316#false} is VALID [2018-11-23 12:11:56,351 INFO L134 CoverageAnalysis]: Checked inductivity of 703 backedges. 0 proven. 703 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:11:56,369 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:11:56,370 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [40, 40] total 41 [2018-11-23 12:11:56,370 INFO L78 Accepts]: Start accepts. Automaton has 41 states. Word has length 50 [2018-11-23 12:11:56,370 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:11:56,370 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 41 states. [2018-11-23 12:11:56,435 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:11:56,435 INFO L459 AbstractCegarLoop]: Interpolant automaton has 41 states [2018-11-23 12:11:56,435 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 41 interpolants. [2018-11-23 12:11:56,436 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=820, Invalid=820, Unknown=0, NotChecked=0, Total=1640 [2018-11-23 12:11:56,436 INFO L87 Difference]: Start difference. First operand 55 states and 56 transitions. Second operand 41 states. [2018-11-23 12:11:56,622 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:56,622 INFO L93 Difference]: Finished difference Result 67 states and 69 transitions. [2018-11-23 12:11:56,622 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 40 states. [2018-11-23 12:11:56,623 INFO L78 Accepts]: Start accepts. Automaton has 41 states. Word has length 50 [2018-11-23 12:11:56,623 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:11:56,623 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 41 states. [2018-11-23 12:11:56,624 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 40 states to 40 states and 69 transitions. [2018-11-23 12:11:56,624 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 41 states. [2018-11-23 12:11:56,625 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 40 states to 40 states and 69 transitions. [2018-11-23 12:11:56,625 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 40 states and 69 transitions. [2018-11-23 12:11:56,680 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 69 edges. 69 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:56,681 INFO L225 Difference]: With dead ends: 67 [2018-11-23 12:11:56,681 INFO L226 Difference]: Without dead ends: 56 [2018-11-23 12:11:56,682 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 89 GetRequests, 50 SyntacticMatches, 0 SemanticMatches, 39 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 72 ImplicationChecksByTransitivity, 0.7s TimeCoverageRelationStatistics Valid=820, Invalid=820, Unknown=0, NotChecked=0, Total=1640 [2018-11-23 12:11:56,683 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 56 states. [2018-11-23 12:11:56,713 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 56 to 56. [2018-11-23 12:11:56,713 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:11:56,714 INFO L82 GeneralOperation]: Start isEquivalent. First operand 56 states. Second operand 56 states. [2018-11-23 12:11:56,714 INFO L74 IsIncluded]: Start isIncluded. First operand 56 states. Second operand 56 states. [2018-11-23 12:11:56,714 INFO L87 Difference]: Start difference. First operand 56 states. Second operand 56 states. [2018-11-23 12:11:56,715 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:56,715 INFO L93 Difference]: Finished difference Result 56 states and 57 transitions. [2018-11-23 12:11:56,715 INFO L276 IsEmpty]: Start isEmpty. Operand 56 states and 57 transitions. [2018-11-23 12:11:56,715 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:56,715 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:56,715 INFO L74 IsIncluded]: Start isIncluded. First operand 56 states. Second operand 56 states. [2018-11-23 12:11:56,716 INFO L87 Difference]: Start difference. First operand 56 states. Second operand 56 states. [2018-11-23 12:11:56,716 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:56,716 INFO L93 Difference]: Finished difference Result 56 states and 57 transitions. [2018-11-23 12:11:56,717 INFO L276 IsEmpty]: Start isEmpty. Operand 56 states and 57 transitions. [2018-11-23 12:11:56,717 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:56,717 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:56,717 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:11:56,717 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:11:56,717 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 56 states. [2018-11-23 12:11:56,718 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 56 states to 56 states and 57 transitions. [2018-11-23 12:11:56,718 INFO L78 Accepts]: Start accepts. Automaton has 56 states and 57 transitions. Word has length 50 [2018-11-23 12:11:56,718 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:11:56,718 INFO L480 AbstractCegarLoop]: Abstraction has 56 states and 57 transitions. [2018-11-23 12:11:56,719 INFO L481 AbstractCegarLoop]: Interpolant automaton has 41 states. [2018-11-23 12:11:56,719 INFO L276 IsEmpty]: Start isEmpty. Operand 56 states and 57 transitions. [2018-11-23 12:11:56,719 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 52 [2018-11-23 12:11:56,719 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:11:56,719 INFO L402 BasicCegarLoop]: trace histogram [38, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:11:56,719 INFO L423 AbstractCegarLoop]: === Iteration 40 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:11:56,719 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:11:56,719 INFO L82 PathProgramCache]: Analyzing trace with hash 327811634, now seen corresponding path program 38 times [2018-11-23 12:11:56,720 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:11:56,720 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:11:56,720 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:56,720 INFO L103 rtionOrderModulation]: Keeping assertion order NOT_INCREMENTALLY [2018-11-23 12:11:56,720 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:56,757 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:57,602 INFO L256 TraceCheckUtils]: 0: Hoare triple {12835#true} call ULTIMATE.init(); {12835#true} is VALID [2018-11-23 12:11:57,602 INFO L273 TraceCheckUtils]: 1: Hoare triple {12835#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {12835#true} is VALID [2018-11-23 12:11:57,602 INFO L273 TraceCheckUtils]: 2: Hoare triple {12835#true} assume true; {12835#true} is VALID [2018-11-23 12:11:57,603 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {12835#true} {12835#true} #48#return; {12835#true} is VALID [2018-11-23 12:11:57,603 INFO L256 TraceCheckUtils]: 4: Hoare triple {12835#true} call #t~ret6 := main(); {12835#true} is VALID [2018-11-23 12:11:57,603 INFO L273 TraceCheckUtils]: 5: Hoare triple {12835#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {12837#(= main_~i~0 0)} is VALID [2018-11-23 12:11:57,605 INFO L273 TraceCheckUtils]: 6: Hoare triple {12837#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12838#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:57,606 INFO L273 TraceCheckUtils]: 7: Hoare triple {12838#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12839#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:57,607 INFO L273 TraceCheckUtils]: 8: Hoare triple {12839#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12840#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:57,608 INFO L273 TraceCheckUtils]: 9: Hoare triple {12840#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12841#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:57,609 INFO L273 TraceCheckUtils]: 10: Hoare triple {12841#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12842#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:57,610 INFO L273 TraceCheckUtils]: 11: Hoare triple {12842#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12843#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:57,611 INFO L273 TraceCheckUtils]: 12: Hoare triple {12843#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12844#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:57,612 INFO L273 TraceCheckUtils]: 13: Hoare triple {12844#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12845#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:57,613 INFO L273 TraceCheckUtils]: 14: Hoare triple {12845#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12846#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:57,614 INFO L273 TraceCheckUtils]: 15: Hoare triple {12846#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12847#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:57,615 INFO L273 TraceCheckUtils]: 16: Hoare triple {12847#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12848#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:57,616 INFO L273 TraceCheckUtils]: 17: Hoare triple {12848#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12849#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:57,618 INFO L273 TraceCheckUtils]: 18: Hoare triple {12849#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12850#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:57,619 INFO L273 TraceCheckUtils]: 19: Hoare triple {12850#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12851#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:57,620 INFO L273 TraceCheckUtils]: 20: Hoare triple {12851#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12852#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:57,621 INFO L273 TraceCheckUtils]: 21: Hoare triple {12852#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12853#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:57,622 INFO L273 TraceCheckUtils]: 22: Hoare triple {12853#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12854#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:57,623 INFO L273 TraceCheckUtils]: 23: Hoare triple {12854#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12855#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:57,624 INFO L273 TraceCheckUtils]: 24: Hoare triple {12855#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12856#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:57,625 INFO L273 TraceCheckUtils]: 25: Hoare triple {12856#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12857#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:57,626 INFO L273 TraceCheckUtils]: 26: Hoare triple {12857#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12858#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:57,627 INFO L273 TraceCheckUtils]: 27: Hoare triple {12858#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12859#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:57,628 INFO L273 TraceCheckUtils]: 28: Hoare triple {12859#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12860#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:57,629 INFO L273 TraceCheckUtils]: 29: Hoare triple {12860#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12861#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:57,630 INFO L273 TraceCheckUtils]: 30: Hoare triple {12861#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12862#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:57,631 INFO L273 TraceCheckUtils]: 31: Hoare triple {12862#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12863#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:57,633 INFO L273 TraceCheckUtils]: 32: Hoare triple {12863#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12864#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:57,634 INFO L273 TraceCheckUtils]: 33: Hoare triple {12864#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12865#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:57,637 INFO L273 TraceCheckUtils]: 34: Hoare triple {12865#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12866#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:57,638 INFO L273 TraceCheckUtils]: 35: Hoare triple {12866#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12867#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:57,639 INFO L273 TraceCheckUtils]: 36: Hoare triple {12867#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12868#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:57,640 INFO L273 TraceCheckUtils]: 37: Hoare triple {12868#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12869#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:57,640 INFO L273 TraceCheckUtils]: 38: Hoare triple {12869#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12870#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:57,641 INFO L273 TraceCheckUtils]: 39: Hoare triple {12870#(<= main_~i~0 33)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12871#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:57,642 INFO L273 TraceCheckUtils]: 40: Hoare triple {12871#(<= main_~i~0 34)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12872#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:57,643 INFO L273 TraceCheckUtils]: 41: Hoare triple {12872#(<= main_~i~0 35)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12873#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:57,644 INFO L273 TraceCheckUtils]: 42: Hoare triple {12873#(<= main_~i~0 36)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12874#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:57,645 INFO L273 TraceCheckUtils]: 43: Hoare triple {12874#(<= main_~i~0 37)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12875#(<= main_~i~0 38)} is VALID [2018-11-23 12:11:57,646 INFO L273 TraceCheckUtils]: 44: Hoare triple {12875#(<= main_~i~0 38)} assume !(~i~0 < 100000); {12836#false} is VALID [2018-11-23 12:11:57,646 INFO L273 TraceCheckUtils]: 45: Hoare triple {12836#false} havoc ~x~0;~x~0 := 0; {12836#false} is VALID [2018-11-23 12:11:57,646 INFO L273 TraceCheckUtils]: 46: Hoare triple {12836#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {12836#false} is VALID [2018-11-23 12:11:57,646 INFO L256 TraceCheckUtils]: 47: Hoare triple {12836#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {12836#false} is VALID [2018-11-23 12:11:57,647 INFO L273 TraceCheckUtils]: 48: Hoare triple {12836#false} ~cond := #in~cond; {12836#false} is VALID [2018-11-23 12:11:57,647 INFO L273 TraceCheckUtils]: 49: Hoare triple {12836#false} assume 0 == ~cond; {12836#false} is VALID [2018-11-23 12:11:57,647 INFO L273 TraceCheckUtils]: 50: Hoare triple {12836#false} assume !false; {12836#false} is VALID [2018-11-23 12:11:57,650 INFO L134 CoverageAnalysis]: Checked inductivity of 741 backedges. 0 proven. 741 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:11:57,650 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:11:57,650 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 39 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 39 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:11:57,658 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST1 [2018-11-23 12:11:57,707 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST1 issued 2 check-sat command(s) [2018-11-23 12:11:57,707 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:11:57,725 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:57,727 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:11:58,074 INFO L256 TraceCheckUtils]: 0: Hoare triple {12835#true} call ULTIMATE.init(); {12835#true} is VALID [2018-11-23 12:11:58,075 INFO L273 TraceCheckUtils]: 1: Hoare triple {12835#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {12835#true} is VALID [2018-11-23 12:11:58,075 INFO L273 TraceCheckUtils]: 2: Hoare triple {12835#true} assume true; {12835#true} is VALID [2018-11-23 12:11:58,075 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {12835#true} {12835#true} #48#return; {12835#true} is VALID [2018-11-23 12:11:58,075 INFO L256 TraceCheckUtils]: 4: Hoare triple {12835#true} call #t~ret6 := main(); {12835#true} is VALID [2018-11-23 12:11:58,076 INFO L273 TraceCheckUtils]: 5: Hoare triple {12835#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {12894#(<= main_~i~0 0)} is VALID [2018-11-23 12:11:58,077 INFO L273 TraceCheckUtils]: 6: Hoare triple {12894#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12838#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:58,078 INFO L273 TraceCheckUtils]: 7: Hoare triple {12838#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12839#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:58,079 INFO L273 TraceCheckUtils]: 8: Hoare triple {12839#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12840#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:58,079 INFO L273 TraceCheckUtils]: 9: Hoare triple {12840#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12841#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:58,080 INFO L273 TraceCheckUtils]: 10: Hoare triple {12841#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12842#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:58,081 INFO L273 TraceCheckUtils]: 11: Hoare triple {12842#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12843#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:58,082 INFO L273 TraceCheckUtils]: 12: Hoare triple {12843#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12844#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:58,083 INFO L273 TraceCheckUtils]: 13: Hoare triple {12844#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12845#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:58,084 INFO L273 TraceCheckUtils]: 14: Hoare triple {12845#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12846#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:58,085 INFO L273 TraceCheckUtils]: 15: Hoare triple {12846#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12847#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:58,086 INFO L273 TraceCheckUtils]: 16: Hoare triple {12847#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12848#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:58,087 INFO L273 TraceCheckUtils]: 17: Hoare triple {12848#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12849#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:58,088 INFO L273 TraceCheckUtils]: 18: Hoare triple {12849#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12850#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:58,090 INFO L273 TraceCheckUtils]: 19: Hoare triple {12850#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12851#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:58,091 INFO L273 TraceCheckUtils]: 20: Hoare triple {12851#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12852#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:58,092 INFO L273 TraceCheckUtils]: 21: Hoare triple {12852#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12853#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:58,093 INFO L273 TraceCheckUtils]: 22: Hoare triple {12853#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12854#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:58,094 INFO L273 TraceCheckUtils]: 23: Hoare triple {12854#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12855#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:58,095 INFO L273 TraceCheckUtils]: 24: Hoare triple {12855#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12856#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:58,096 INFO L273 TraceCheckUtils]: 25: Hoare triple {12856#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12857#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:58,097 INFO L273 TraceCheckUtils]: 26: Hoare triple {12857#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12858#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:58,098 INFO L273 TraceCheckUtils]: 27: Hoare triple {12858#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12859#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:58,099 INFO L273 TraceCheckUtils]: 28: Hoare triple {12859#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12860#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:58,100 INFO L273 TraceCheckUtils]: 29: Hoare triple {12860#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12861#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:58,101 INFO L273 TraceCheckUtils]: 30: Hoare triple {12861#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12862#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:58,102 INFO L273 TraceCheckUtils]: 31: Hoare triple {12862#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12863#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:58,110 INFO L273 TraceCheckUtils]: 32: Hoare triple {12863#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12864#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:58,111 INFO L273 TraceCheckUtils]: 33: Hoare triple {12864#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12865#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:58,111 INFO L273 TraceCheckUtils]: 34: Hoare triple {12865#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12866#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:58,112 INFO L273 TraceCheckUtils]: 35: Hoare triple {12866#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12867#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:58,113 INFO L273 TraceCheckUtils]: 36: Hoare triple {12867#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12868#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:58,113 INFO L273 TraceCheckUtils]: 37: Hoare triple {12868#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12869#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:58,124 INFO L273 TraceCheckUtils]: 38: Hoare triple {12869#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12870#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:58,125 INFO L273 TraceCheckUtils]: 39: Hoare triple {12870#(<= main_~i~0 33)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12871#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:58,126 INFO L273 TraceCheckUtils]: 40: Hoare triple {12871#(<= main_~i~0 34)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12872#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:58,126 INFO L273 TraceCheckUtils]: 41: Hoare triple {12872#(<= main_~i~0 35)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12873#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:58,127 INFO L273 TraceCheckUtils]: 42: Hoare triple {12873#(<= main_~i~0 36)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12874#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:58,128 INFO L273 TraceCheckUtils]: 43: Hoare triple {12874#(<= main_~i~0 37)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {12875#(<= main_~i~0 38)} is VALID [2018-11-23 12:11:58,129 INFO L273 TraceCheckUtils]: 44: Hoare triple {12875#(<= main_~i~0 38)} assume !(~i~0 < 100000); {12836#false} is VALID [2018-11-23 12:11:58,129 INFO L273 TraceCheckUtils]: 45: Hoare triple {12836#false} havoc ~x~0;~x~0 := 0; {12836#false} is VALID [2018-11-23 12:11:58,129 INFO L273 TraceCheckUtils]: 46: Hoare triple {12836#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {12836#false} is VALID [2018-11-23 12:11:58,130 INFO L256 TraceCheckUtils]: 47: Hoare triple {12836#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {12836#false} is VALID [2018-11-23 12:11:58,130 INFO L273 TraceCheckUtils]: 48: Hoare triple {12836#false} ~cond := #in~cond; {12836#false} is VALID [2018-11-23 12:11:58,130 INFO L273 TraceCheckUtils]: 49: Hoare triple {12836#false} assume 0 == ~cond; {12836#false} is VALID [2018-11-23 12:11:58,130 INFO L273 TraceCheckUtils]: 50: Hoare triple {12836#false} assume !false; {12836#false} is VALID [2018-11-23 12:11:58,133 INFO L134 CoverageAnalysis]: Checked inductivity of 741 backedges. 0 proven. 741 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:11:58,152 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:11:58,152 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [41, 41] total 42 [2018-11-23 12:11:58,152 INFO L78 Accepts]: Start accepts. Automaton has 42 states. Word has length 51 [2018-11-23 12:11:58,152 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:11:58,153 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 42 states. [2018-11-23 12:11:58,192 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:11:58,192 INFO L459 AbstractCegarLoop]: Interpolant automaton has 42 states [2018-11-23 12:11:58,193 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 42 interpolants. [2018-11-23 12:11:58,193 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=861, Invalid=861, Unknown=0, NotChecked=0, Total=1722 [2018-11-23 12:11:58,194 INFO L87 Difference]: Start difference. First operand 56 states and 57 transitions. Second operand 42 states. [2018-11-23 12:11:58,487 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:58,487 INFO L93 Difference]: Finished difference Result 68 states and 70 transitions. [2018-11-23 12:11:58,488 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 41 states. [2018-11-23 12:11:58,488 INFO L78 Accepts]: Start accepts. Automaton has 42 states. Word has length 51 [2018-11-23 12:11:58,488 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:11:58,488 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 42 states. [2018-11-23 12:11:58,489 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 41 states to 41 states and 70 transitions. [2018-11-23 12:11:58,490 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 42 states. [2018-11-23 12:11:58,490 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 41 states to 41 states and 70 transitions. [2018-11-23 12:11:58,491 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 41 states and 70 transitions. [2018-11-23 12:11:58,545 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 70 edges. 70 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:11:58,546 INFO L225 Difference]: With dead ends: 68 [2018-11-23 12:11:58,546 INFO L226 Difference]: Without dead ends: 57 [2018-11-23 12:11:58,547 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 91 GetRequests, 51 SyntacticMatches, 0 SemanticMatches, 40 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 74 ImplicationChecksByTransitivity, 0.6s TimeCoverageRelationStatistics Valid=861, Invalid=861, Unknown=0, NotChecked=0, Total=1722 [2018-11-23 12:11:58,547 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 57 states. [2018-11-23 12:11:58,587 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 57 to 57. [2018-11-23 12:11:58,587 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:11:58,587 INFO L82 GeneralOperation]: Start isEquivalent. First operand 57 states. Second operand 57 states. [2018-11-23 12:11:58,587 INFO L74 IsIncluded]: Start isIncluded. First operand 57 states. Second operand 57 states. [2018-11-23 12:11:58,588 INFO L87 Difference]: Start difference. First operand 57 states. Second operand 57 states. [2018-11-23 12:11:58,588 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:58,589 INFO L93 Difference]: Finished difference Result 57 states and 58 transitions. [2018-11-23 12:11:58,589 INFO L276 IsEmpty]: Start isEmpty. Operand 57 states and 58 transitions. [2018-11-23 12:11:58,589 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:58,589 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:58,589 INFO L74 IsIncluded]: Start isIncluded. First operand 57 states. Second operand 57 states. [2018-11-23 12:11:58,589 INFO L87 Difference]: Start difference. First operand 57 states. Second operand 57 states. [2018-11-23 12:11:58,590 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:11:58,590 INFO L93 Difference]: Finished difference Result 57 states and 58 transitions. [2018-11-23 12:11:58,591 INFO L276 IsEmpty]: Start isEmpty. Operand 57 states and 58 transitions. [2018-11-23 12:11:58,591 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:11:58,591 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:11:58,591 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:11:58,591 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:11:58,591 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 57 states. [2018-11-23 12:11:58,592 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 57 states to 57 states and 58 transitions. [2018-11-23 12:11:58,592 INFO L78 Accepts]: Start accepts. Automaton has 57 states and 58 transitions. Word has length 51 [2018-11-23 12:11:58,593 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:11:58,593 INFO L480 AbstractCegarLoop]: Abstraction has 57 states and 58 transitions. [2018-11-23 12:11:58,593 INFO L481 AbstractCegarLoop]: Interpolant automaton has 42 states. [2018-11-23 12:11:58,593 INFO L276 IsEmpty]: Start isEmpty. Operand 57 states and 58 transitions. [2018-11-23 12:11:58,593 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 53 [2018-11-23 12:11:58,593 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:11:58,593 INFO L402 BasicCegarLoop]: trace histogram [39, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:11:58,594 INFO L423 AbstractCegarLoop]: === Iteration 41 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:11:58,594 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:11:58,594 INFO L82 PathProgramCache]: Analyzing trace with hash -518852626, now seen corresponding path program 39 times [2018-11-23 12:11:58,594 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:11:58,594 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:11:58,595 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:58,595 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:11:58,595 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:11:58,640 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:11:59,499 INFO L256 TraceCheckUtils]: 0: Hoare triple {13365#true} call ULTIMATE.init(); {13365#true} is VALID [2018-11-23 12:11:59,499 INFO L273 TraceCheckUtils]: 1: Hoare triple {13365#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {13365#true} is VALID [2018-11-23 12:11:59,499 INFO L273 TraceCheckUtils]: 2: Hoare triple {13365#true} assume true; {13365#true} is VALID [2018-11-23 12:11:59,499 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {13365#true} {13365#true} #48#return; {13365#true} is VALID [2018-11-23 12:11:59,500 INFO L256 TraceCheckUtils]: 4: Hoare triple {13365#true} call #t~ret6 := main(); {13365#true} is VALID [2018-11-23 12:11:59,501 INFO L273 TraceCheckUtils]: 5: Hoare triple {13365#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {13367#(= main_~i~0 0)} is VALID [2018-11-23 12:11:59,502 INFO L273 TraceCheckUtils]: 6: Hoare triple {13367#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13368#(<= main_~i~0 1)} is VALID [2018-11-23 12:11:59,503 INFO L273 TraceCheckUtils]: 7: Hoare triple {13368#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13369#(<= main_~i~0 2)} is VALID [2018-11-23 12:11:59,503 INFO L273 TraceCheckUtils]: 8: Hoare triple {13369#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13370#(<= main_~i~0 3)} is VALID [2018-11-23 12:11:59,504 INFO L273 TraceCheckUtils]: 9: Hoare triple {13370#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13371#(<= main_~i~0 4)} is VALID [2018-11-23 12:11:59,506 INFO L273 TraceCheckUtils]: 10: Hoare triple {13371#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13372#(<= main_~i~0 5)} is VALID [2018-11-23 12:11:59,507 INFO L273 TraceCheckUtils]: 11: Hoare triple {13372#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13373#(<= main_~i~0 6)} is VALID [2018-11-23 12:11:59,508 INFO L273 TraceCheckUtils]: 12: Hoare triple {13373#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13374#(<= main_~i~0 7)} is VALID [2018-11-23 12:11:59,509 INFO L273 TraceCheckUtils]: 13: Hoare triple {13374#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13375#(<= main_~i~0 8)} is VALID [2018-11-23 12:11:59,510 INFO L273 TraceCheckUtils]: 14: Hoare triple {13375#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13376#(<= main_~i~0 9)} is VALID [2018-11-23 12:11:59,511 INFO L273 TraceCheckUtils]: 15: Hoare triple {13376#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13377#(<= main_~i~0 10)} is VALID [2018-11-23 12:11:59,512 INFO L273 TraceCheckUtils]: 16: Hoare triple {13377#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13378#(<= main_~i~0 11)} is VALID [2018-11-23 12:11:59,513 INFO L273 TraceCheckUtils]: 17: Hoare triple {13378#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13379#(<= main_~i~0 12)} is VALID [2018-11-23 12:11:59,514 INFO L273 TraceCheckUtils]: 18: Hoare triple {13379#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13380#(<= main_~i~0 13)} is VALID [2018-11-23 12:11:59,535 INFO L273 TraceCheckUtils]: 19: Hoare triple {13380#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13381#(<= main_~i~0 14)} is VALID [2018-11-23 12:11:59,549 INFO L273 TraceCheckUtils]: 20: Hoare triple {13381#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13382#(<= main_~i~0 15)} is VALID [2018-11-23 12:11:59,563 INFO L273 TraceCheckUtils]: 21: Hoare triple {13382#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13383#(<= main_~i~0 16)} is VALID [2018-11-23 12:11:59,579 INFO L273 TraceCheckUtils]: 22: Hoare triple {13383#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13384#(<= main_~i~0 17)} is VALID [2018-11-23 12:11:59,589 INFO L273 TraceCheckUtils]: 23: Hoare triple {13384#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13385#(<= main_~i~0 18)} is VALID [2018-11-23 12:11:59,590 INFO L273 TraceCheckUtils]: 24: Hoare triple {13385#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13386#(<= main_~i~0 19)} is VALID [2018-11-23 12:11:59,591 INFO L273 TraceCheckUtils]: 25: Hoare triple {13386#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13387#(<= main_~i~0 20)} is VALID [2018-11-23 12:11:59,591 INFO L273 TraceCheckUtils]: 26: Hoare triple {13387#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13388#(<= main_~i~0 21)} is VALID [2018-11-23 12:11:59,592 INFO L273 TraceCheckUtils]: 27: Hoare triple {13388#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13389#(<= main_~i~0 22)} is VALID [2018-11-23 12:11:59,593 INFO L273 TraceCheckUtils]: 28: Hoare triple {13389#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13390#(<= main_~i~0 23)} is VALID [2018-11-23 12:11:59,594 INFO L273 TraceCheckUtils]: 29: Hoare triple {13390#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13391#(<= main_~i~0 24)} is VALID [2018-11-23 12:11:59,595 INFO L273 TraceCheckUtils]: 30: Hoare triple {13391#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13392#(<= main_~i~0 25)} is VALID [2018-11-23 12:11:59,596 INFO L273 TraceCheckUtils]: 31: Hoare triple {13392#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13393#(<= main_~i~0 26)} is VALID [2018-11-23 12:11:59,597 INFO L273 TraceCheckUtils]: 32: Hoare triple {13393#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13394#(<= main_~i~0 27)} is VALID [2018-11-23 12:11:59,598 INFO L273 TraceCheckUtils]: 33: Hoare triple {13394#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13395#(<= main_~i~0 28)} is VALID [2018-11-23 12:11:59,599 INFO L273 TraceCheckUtils]: 34: Hoare triple {13395#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13396#(<= main_~i~0 29)} is VALID [2018-11-23 12:11:59,600 INFO L273 TraceCheckUtils]: 35: Hoare triple {13396#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13397#(<= main_~i~0 30)} is VALID [2018-11-23 12:11:59,601 INFO L273 TraceCheckUtils]: 36: Hoare triple {13397#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13398#(<= main_~i~0 31)} is VALID [2018-11-23 12:11:59,602 INFO L273 TraceCheckUtils]: 37: Hoare triple {13398#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13399#(<= main_~i~0 32)} is VALID [2018-11-23 12:11:59,604 INFO L273 TraceCheckUtils]: 38: Hoare triple {13399#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13400#(<= main_~i~0 33)} is VALID [2018-11-23 12:11:59,605 INFO L273 TraceCheckUtils]: 39: Hoare triple {13400#(<= main_~i~0 33)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13401#(<= main_~i~0 34)} is VALID [2018-11-23 12:11:59,606 INFO L273 TraceCheckUtils]: 40: Hoare triple {13401#(<= main_~i~0 34)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13402#(<= main_~i~0 35)} is VALID [2018-11-23 12:11:59,607 INFO L273 TraceCheckUtils]: 41: Hoare triple {13402#(<= main_~i~0 35)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13403#(<= main_~i~0 36)} is VALID [2018-11-23 12:11:59,608 INFO L273 TraceCheckUtils]: 42: Hoare triple {13403#(<= main_~i~0 36)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13404#(<= main_~i~0 37)} is VALID [2018-11-23 12:11:59,609 INFO L273 TraceCheckUtils]: 43: Hoare triple {13404#(<= main_~i~0 37)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13405#(<= main_~i~0 38)} is VALID [2018-11-23 12:11:59,610 INFO L273 TraceCheckUtils]: 44: Hoare triple {13405#(<= main_~i~0 38)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13406#(<= main_~i~0 39)} is VALID [2018-11-23 12:11:59,611 INFO L273 TraceCheckUtils]: 45: Hoare triple {13406#(<= main_~i~0 39)} assume !(~i~0 < 100000); {13366#false} is VALID [2018-11-23 12:11:59,611 INFO L273 TraceCheckUtils]: 46: Hoare triple {13366#false} havoc ~x~0;~x~0 := 0; {13366#false} is VALID [2018-11-23 12:11:59,611 INFO L273 TraceCheckUtils]: 47: Hoare triple {13366#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {13366#false} is VALID [2018-11-23 12:11:59,611 INFO L256 TraceCheckUtils]: 48: Hoare triple {13366#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {13366#false} is VALID [2018-11-23 12:11:59,612 INFO L273 TraceCheckUtils]: 49: Hoare triple {13366#false} ~cond := #in~cond; {13366#false} is VALID [2018-11-23 12:11:59,612 INFO L273 TraceCheckUtils]: 50: Hoare triple {13366#false} assume 0 == ~cond; {13366#false} is VALID [2018-11-23 12:11:59,612 INFO L273 TraceCheckUtils]: 51: Hoare triple {13366#false} assume !false; {13366#false} is VALID [2018-11-23 12:11:59,615 INFO L134 CoverageAnalysis]: Checked inductivity of 780 backedges. 0 proven. 780 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:11:59,615 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:11:59,615 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 40 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 40 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:11:59,624 INFO L103 rtionOrderModulation]: Keeping assertion order OUTSIDE_LOOP_FIRST2 [2018-11-23 12:13:08,173 INFO L249 tOrderPrioritization]: Assert order OUTSIDE_LOOP_FIRST2 issued 21 check-sat command(s) [2018-11-23 12:13:08,173 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:13:08,211 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:08,213 INFO L273 TraceCheckSpWp]: Computing forward predicates... [2018-11-23 12:13:08,423 INFO L256 TraceCheckUtils]: 0: Hoare triple {13365#true} call ULTIMATE.init(); {13365#true} is VALID [2018-11-23 12:13:08,423 INFO L273 TraceCheckUtils]: 1: Hoare triple {13365#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {13365#true} is VALID [2018-11-23 12:13:08,424 INFO L273 TraceCheckUtils]: 2: Hoare triple {13365#true} assume true; {13365#true} is VALID [2018-11-23 12:13:08,424 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {13365#true} {13365#true} #48#return; {13365#true} is VALID [2018-11-23 12:13:08,424 INFO L256 TraceCheckUtils]: 4: Hoare triple {13365#true} call #t~ret6 := main(); {13365#true} is VALID [2018-11-23 12:13:08,425 INFO L273 TraceCheckUtils]: 5: Hoare triple {13365#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {13425#(<= main_~i~0 0)} is VALID [2018-11-23 12:13:08,426 INFO L273 TraceCheckUtils]: 6: Hoare triple {13425#(<= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13368#(<= main_~i~0 1)} is VALID [2018-11-23 12:13:08,426 INFO L273 TraceCheckUtils]: 7: Hoare triple {13368#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13369#(<= main_~i~0 2)} is VALID [2018-11-23 12:13:08,427 INFO L273 TraceCheckUtils]: 8: Hoare triple {13369#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13370#(<= main_~i~0 3)} is VALID [2018-11-23 12:13:08,428 INFO L273 TraceCheckUtils]: 9: Hoare triple {13370#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13371#(<= main_~i~0 4)} is VALID [2018-11-23 12:13:08,429 INFO L273 TraceCheckUtils]: 10: Hoare triple {13371#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13372#(<= main_~i~0 5)} is VALID [2018-11-23 12:13:08,430 INFO L273 TraceCheckUtils]: 11: Hoare triple {13372#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13373#(<= main_~i~0 6)} is VALID [2018-11-23 12:13:08,431 INFO L273 TraceCheckUtils]: 12: Hoare triple {13373#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13374#(<= main_~i~0 7)} is VALID [2018-11-23 12:13:08,432 INFO L273 TraceCheckUtils]: 13: Hoare triple {13374#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13375#(<= main_~i~0 8)} is VALID [2018-11-23 12:13:08,433 INFO L273 TraceCheckUtils]: 14: Hoare triple {13375#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13376#(<= main_~i~0 9)} is VALID [2018-11-23 12:13:08,434 INFO L273 TraceCheckUtils]: 15: Hoare triple {13376#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13377#(<= main_~i~0 10)} is VALID [2018-11-23 12:13:08,435 INFO L273 TraceCheckUtils]: 16: Hoare triple {13377#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13378#(<= main_~i~0 11)} is VALID [2018-11-23 12:13:08,436 INFO L273 TraceCheckUtils]: 17: Hoare triple {13378#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13379#(<= main_~i~0 12)} is VALID [2018-11-23 12:13:08,437 INFO L273 TraceCheckUtils]: 18: Hoare triple {13379#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13380#(<= main_~i~0 13)} is VALID [2018-11-23 12:13:08,438 INFO L273 TraceCheckUtils]: 19: Hoare triple {13380#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13381#(<= main_~i~0 14)} is VALID [2018-11-23 12:13:08,439 INFO L273 TraceCheckUtils]: 20: Hoare triple {13381#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13382#(<= main_~i~0 15)} is VALID [2018-11-23 12:13:08,440 INFO L273 TraceCheckUtils]: 21: Hoare triple {13382#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13383#(<= main_~i~0 16)} is VALID [2018-11-23 12:13:08,441 INFO L273 TraceCheckUtils]: 22: Hoare triple {13383#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13384#(<= main_~i~0 17)} is VALID [2018-11-23 12:13:08,442 INFO L273 TraceCheckUtils]: 23: Hoare triple {13384#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13385#(<= main_~i~0 18)} is VALID [2018-11-23 12:13:08,443 INFO L273 TraceCheckUtils]: 24: Hoare triple {13385#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13386#(<= main_~i~0 19)} is VALID [2018-11-23 12:13:08,444 INFO L273 TraceCheckUtils]: 25: Hoare triple {13386#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13387#(<= main_~i~0 20)} is VALID [2018-11-23 12:13:08,445 INFO L273 TraceCheckUtils]: 26: Hoare triple {13387#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13388#(<= main_~i~0 21)} is VALID [2018-11-23 12:13:08,446 INFO L273 TraceCheckUtils]: 27: Hoare triple {13388#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13389#(<= main_~i~0 22)} is VALID [2018-11-23 12:13:08,447 INFO L273 TraceCheckUtils]: 28: Hoare triple {13389#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13390#(<= main_~i~0 23)} is VALID [2018-11-23 12:13:08,448 INFO L273 TraceCheckUtils]: 29: Hoare triple {13390#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13391#(<= main_~i~0 24)} is VALID [2018-11-23 12:13:08,449 INFO L273 TraceCheckUtils]: 30: Hoare triple {13391#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13392#(<= main_~i~0 25)} is VALID [2018-11-23 12:13:08,450 INFO L273 TraceCheckUtils]: 31: Hoare triple {13392#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13393#(<= main_~i~0 26)} is VALID [2018-11-23 12:13:08,451 INFO L273 TraceCheckUtils]: 32: Hoare triple {13393#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13394#(<= main_~i~0 27)} is VALID [2018-11-23 12:13:08,452 INFO L273 TraceCheckUtils]: 33: Hoare triple {13394#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13395#(<= main_~i~0 28)} is VALID [2018-11-23 12:13:08,453 INFO L273 TraceCheckUtils]: 34: Hoare triple {13395#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13396#(<= main_~i~0 29)} is VALID [2018-11-23 12:13:08,454 INFO L273 TraceCheckUtils]: 35: Hoare triple {13396#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13397#(<= main_~i~0 30)} is VALID [2018-11-23 12:13:08,455 INFO L273 TraceCheckUtils]: 36: Hoare triple {13397#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13398#(<= main_~i~0 31)} is VALID [2018-11-23 12:13:08,456 INFO L273 TraceCheckUtils]: 37: Hoare triple {13398#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13399#(<= main_~i~0 32)} is VALID [2018-11-23 12:13:08,457 INFO L273 TraceCheckUtils]: 38: Hoare triple {13399#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13400#(<= main_~i~0 33)} is VALID [2018-11-23 12:13:08,458 INFO L273 TraceCheckUtils]: 39: Hoare triple {13400#(<= main_~i~0 33)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13401#(<= main_~i~0 34)} is VALID [2018-11-23 12:13:08,459 INFO L273 TraceCheckUtils]: 40: Hoare triple {13401#(<= main_~i~0 34)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13402#(<= main_~i~0 35)} is VALID [2018-11-23 12:13:08,460 INFO L273 TraceCheckUtils]: 41: Hoare triple {13402#(<= main_~i~0 35)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13403#(<= main_~i~0 36)} is VALID [2018-11-23 12:13:08,461 INFO L273 TraceCheckUtils]: 42: Hoare triple {13403#(<= main_~i~0 36)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13404#(<= main_~i~0 37)} is VALID [2018-11-23 12:13:08,462 INFO L273 TraceCheckUtils]: 43: Hoare triple {13404#(<= main_~i~0 37)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13405#(<= main_~i~0 38)} is VALID [2018-11-23 12:13:08,463 INFO L273 TraceCheckUtils]: 44: Hoare triple {13405#(<= main_~i~0 38)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13406#(<= main_~i~0 39)} is VALID [2018-11-23 12:13:08,464 INFO L273 TraceCheckUtils]: 45: Hoare triple {13406#(<= main_~i~0 39)} assume !(~i~0 < 100000); {13366#false} is VALID [2018-11-23 12:13:08,464 INFO L273 TraceCheckUtils]: 46: Hoare triple {13366#false} havoc ~x~0;~x~0 := 0; {13366#false} is VALID [2018-11-23 12:13:08,464 INFO L273 TraceCheckUtils]: 47: Hoare triple {13366#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {13366#false} is VALID [2018-11-23 12:13:08,464 INFO L256 TraceCheckUtils]: 48: Hoare triple {13366#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {13366#false} is VALID [2018-11-23 12:13:08,464 INFO L273 TraceCheckUtils]: 49: Hoare triple {13366#false} ~cond := #in~cond; {13366#false} is VALID [2018-11-23 12:13:08,465 INFO L273 TraceCheckUtils]: 50: Hoare triple {13366#false} assume 0 == ~cond; {13366#false} is VALID [2018-11-23 12:13:08,465 INFO L273 TraceCheckUtils]: 51: Hoare triple {13366#false} assume !false; {13366#false} is VALID [2018-11-23 12:13:08,468 INFO L134 CoverageAnalysis]: Checked inductivity of 780 backedges. 0 proven. 780 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:13:08,495 INFO L312 seRefinementStrategy]: Constructing automaton from 0 perfect and 2 imperfect interpolant sequences. [2018-11-23 12:13:08,495 INFO L327 seRefinementStrategy]: Number of different interpolants: perfect sequences [] imperfect sequences [42, 42] total 43 [2018-11-23 12:13:08,496 INFO L78 Accepts]: Start accepts. Automaton has 43 states. Word has length 52 [2018-11-23 12:13:08,496 INFO L84 Accepts]: Finished accepts. word is accepted. [2018-11-23 12:13:08,496 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 43 states. [2018-11-23 12:13:08,618 INFO L119 InductivityCheck]: Floyd-Hoare automaton has 54 edges. 54 inductive. 0 not inductive. 0 times theorem prover too weak to decide inductivity. [2018-11-23 12:13:08,619 INFO L459 AbstractCegarLoop]: Interpolant automaton has 43 states [2018-11-23 12:13:08,619 INFO L142 InterpolantAutomaton]: Constructing interpolant automaton starting with 43 interpolants. [2018-11-23 12:13:08,620 INFO L144 InterpolantAutomaton]: CoverageRelationStatistics Valid=903, Invalid=903, Unknown=0, NotChecked=0, Total=1806 [2018-11-23 12:13:08,620 INFO L87 Difference]: Start difference. First operand 57 states and 58 transitions. Second operand 43 states. [2018-11-23 12:13:09,082 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:09,083 INFO L93 Difference]: Finished difference Result 69 states and 71 transitions. [2018-11-23 12:13:09,083 INFO L142 InterpolantAutomaton]: Switched to read-only mode: deterministic interpolant automaton has 42 states. [2018-11-23 12:13:09,083 INFO L78 Accepts]: Start accepts. Automaton has 43 states. Word has length 52 [2018-11-23 12:13:09,083 INFO L84 Accepts]: Finished accepts. some prefix is accepted. [2018-11-23 12:13:09,083 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 43 states. [2018-11-23 12:13:09,084 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 42 states to 42 states and 71 transitions. [2018-11-23 12:13:09,084 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 43 states. [2018-11-23 12:13:09,085 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 42 states to 42 states and 71 transitions. [2018-11-23 12:13:09,085 INFO L86 InductivityCheck]: Starting indutivity check of a Floyd-Hoare automaton with 42 states and 71 transitions. [2018-11-23 12:13:09,137 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:13:09,138 INFO L225 Difference]: With dead ends: 69 [2018-11-23 12:13:09,138 INFO L226 Difference]: Without dead ends: 58 [2018-11-23 12:13:09,139 INFO L631 BasicCegarLoop]: 0 DeclaredPredicates, 93 GetRequests, 52 SyntacticMatches, 0 SemanticMatches, 41 ConstructedPredicates, 0 IntricatePredicates, 0 DeprecatedPredicates, 76 ImplicationChecksByTransitivity, 0.6s TimeCoverageRelationStatistics Valid=903, Invalid=903, Unknown=0, NotChecked=0, Total=1806 [2018-11-23 12:13:09,139 INFO L82 GeneralOperation]: Start minimizeSevpa. Operand 58 states. [2018-11-23 12:13:09,174 INFO L88 GeneralOperation]: Finished minimizeSevpa. Reduced states from 58 to 58. [2018-11-23 12:13:09,174 INFO L214 AbstractMinimizeNwa]: Start testing correctness of minimizeSevpa [2018-11-23 12:13:09,174 INFO L82 GeneralOperation]: Start isEquivalent. First operand 58 states. Second operand 58 states. [2018-11-23 12:13:09,174 INFO L74 IsIncluded]: Start isIncluded. First operand 58 states. Second operand 58 states. [2018-11-23 12:13:09,174 INFO L87 Difference]: Start difference. First operand 58 states. Second operand 58 states. [2018-11-23 12:13:09,175 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:09,175 INFO L93 Difference]: Finished difference Result 58 states and 59 transitions. [2018-11-23 12:13:09,175 INFO L276 IsEmpty]: Start isEmpty. Operand 58 states and 59 transitions. [2018-11-23 12:13:09,175 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:09,176 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:09,176 INFO L74 IsIncluded]: Start isIncluded. First operand 58 states. Second operand 58 states. [2018-11-23 12:13:09,176 INFO L87 Difference]: Start difference. First operand 58 states. Second operand 58 states. [2018-11-23 12:13:09,177 INFO L144 Difference]: Subtrahend was deterministic. Have not used determinization. [2018-11-23 12:13:09,177 INFO L93 Difference]: Finished difference Result 58 states and 59 transitions. [2018-11-23 12:13:09,177 INFO L276 IsEmpty]: Start isEmpty. Operand 58 states and 59 transitions. [2018-11-23 12:13:09,177 INFO L282 IsEmpty]: Finished isEmpty. No accepting run. [2018-11-23 12:13:09,177 INFO L83 IsIncluded]: Finished isIncluded. Language is included [2018-11-23 12:13:09,178 INFO L88 GeneralOperation]: Finished isEquivalent. [2018-11-23 12:13:09,178 INFO L221 AbstractMinimizeNwa]: Finished testing correctness of minimizeSevpa [2018-11-23 12:13:09,178 INFO L82 GeneralOperation]: Start removeUnreachable. Operand 58 states. [2018-11-23 12:13:09,178 INFO L88 GeneralOperation]: Finished removeUnreachable. Reduced from 58 states to 58 states and 59 transitions. [2018-11-23 12:13:09,179 INFO L78 Accepts]: Start accepts. Automaton has 58 states and 59 transitions. Word has length 52 [2018-11-23 12:13:09,179 INFO L84 Accepts]: Finished accepts. word is rejected. [2018-11-23 12:13:09,179 INFO L480 AbstractCegarLoop]: Abstraction has 58 states and 59 transitions. [2018-11-23 12:13:09,179 INFO L481 AbstractCegarLoop]: Interpolant automaton has 43 states. [2018-11-23 12:13:09,179 INFO L276 IsEmpty]: Start isEmpty. Operand 58 states and 59 transitions. [2018-11-23 12:13:09,179 INFO L282 IsEmpty]: Finished isEmpty. Found accepting run of length 54 [2018-11-23 12:13:09,179 INFO L394 BasicCegarLoop]: Found error trace [2018-11-23 12:13:09,180 INFO L402 BasicCegarLoop]: trace histogram [40, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] [2018-11-23 12:13:09,180 INFO L423 AbstractCegarLoop]: === Iteration 42 === [__VERIFIER_assertErr0ASSERT_VIOLATIONERROR_FUNCTION]=== [2018-11-23 12:13:09,180 INFO L141 PredicateUnifier]: Initialized classic predicate unifier [2018-11-23 12:13:09,180 INFO L82 PathProgramCache]: Analyzing trace with hash -995640910, now seen corresponding path program 40 times [2018-11-23 12:13:09,180 INFO L223 ckRefinementStrategy]: Switched to mode SMTINTERPOL_TREE_INTERPOLANTS [2018-11-23 12:13:09,180 INFO L69 tionRefinementEngine]: Using refinement strategy CamelRefinementStrategy [2018-11-23 12:13:09,181 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:09,181 INFO L101 rtionOrderModulation]: Changing assertion order to NOT_INCREMENTALLY [2018-11-23 12:13:09,181 INFO L119 rtionOrderModulation]: Craig_TreeInterpolation forces the order to NOT_INCREMENTALLY [2018-11-23 12:13:09,218 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:10,095 INFO L256 TraceCheckUtils]: 0: Hoare triple {13905#true} call ULTIMATE.init(); {13905#true} is VALID [2018-11-23 12:13:10,095 INFO L273 TraceCheckUtils]: 1: Hoare triple {13905#true} #NULL.base, #NULL.offset := 0, 0;#valid := #valid[0 := 0]; {13905#true} is VALID [2018-11-23 12:13:10,095 INFO L273 TraceCheckUtils]: 2: Hoare triple {13905#true} assume true; {13905#true} is VALID [2018-11-23 12:13:10,095 INFO L268 TraceCheckUtils]: 3: Hoare quadruple {13905#true} {13905#true} #48#return; {13905#true} is VALID [2018-11-23 12:13:10,096 INFO L256 TraceCheckUtils]: 4: Hoare triple {13905#true} call #t~ret6 := main(); {13905#true} is VALID [2018-11-23 12:13:10,096 INFO L273 TraceCheckUtils]: 5: Hoare triple {13905#true} call ~#a~0.base, ~#a~0.offset := #Ultimate.alloc(400000);call ~#b~0.base, ~#b~0.offset := #Ultimate.alloc(400000);call ~#c~0.base, ~#c~0.offset := #Ultimate.alloc(400000);~i~0 := 0; {13907#(= main_~i~0 0)} is VALID [2018-11-23 12:13:10,097 INFO L273 TraceCheckUtils]: 6: Hoare triple {13907#(= main_~i~0 0)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13908#(<= main_~i~0 1)} is VALID [2018-11-23 12:13:10,098 INFO L273 TraceCheckUtils]: 7: Hoare triple {13908#(<= main_~i~0 1)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13909#(<= main_~i~0 2)} is VALID [2018-11-23 12:13:10,099 INFO L273 TraceCheckUtils]: 8: Hoare triple {13909#(<= main_~i~0 2)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13910#(<= main_~i~0 3)} is VALID [2018-11-23 12:13:10,099 INFO L273 TraceCheckUtils]: 9: Hoare triple {13910#(<= main_~i~0 3)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13911#(<= main_~i~0 4)} is VALID [2018-11-23 12:13:10,100 INFO L273 TraceCheckUtils]: 10: Hoare triple {13911#(<= main_~i~0 4)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13912#(<= main_~i~0 5)} is VALID [2018-11-23 12:13:10,101 INFO L273 TraceCheckUtils]: 11: Hoare triple {13912#(<= main_~i~0 5)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13913#(<= main_~i~0 6)} is VALID [2018-11-23 12:13:10,102 INFO L273 TraceCheckUtils]: 12: Hoare triple {13913#(<= main_~i~0 6)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13914#(<= main_~i~0 7)} is VALID [2018-11-23 12:13:10,103 INFO L273 TraceCheckUtils]: 13: Hoare triple {13914#(<= main_~i~0 7)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13915#(<= main_~i~0 8)} is VALID [2018-11-23 12:13:10,104 INFO L273 TraceCheckUtils]: 14: Hoare triple {13915#(<= main_~i~0 8)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13916#(<= main_~i~0 9)} is VALID [2018-11-23 12:13:10,105 INFO L273 TraceCheckUtils]: 15: Hoare triple {13916#(<= main_~i~0 9)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13917#(<= main_~i~0 10)} is VALID [2018-11-23 12:13:10,106 INFO L273 TraceCheckUtils]: 16: Hoare triple {13917#(<= main_~i~0 10)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13918#(<= main_~i~0 11)} is VALID [2018-11-23 12:13:10,107 INFO L273 TraceCheckUtils]: 17: Hoare triple {13918#(<= main_~i~0 11)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13919#(<= main_~i~0 12)} is VALID [2018-11-23 12:13:10,108 INFO L273 TraceCheckUtils]: 18: Hoare triple {13919#(<= main_~i~0 12)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13920#(<= main_~i~0 13)} is VALID [2018-11-23 12:13:10,109 INFO L273 TraceCheckUtils]: 19: Hoare triple {13920#(<= main_~i~0 13)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13921#(<= main_~i~0 14)} is VALID [2018-11-23 12:13:10,111 INFO L273 TraceCheckUtils]: 20: Hoare triple {13921#(<= main_~i~0 14)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13922#(<= main_~i~0 15)} is VALID [2018-11-23 12:13:10,112 INFO L273 TraceCheckUtils]: 21: Hoare triple {13922#(<= main_~i~0 15)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13923#(<= main_~i~0 16)} is VALID [2018-11-23 12:13:10,113 INFO L273 TraceCheckUtils]: 22: Hoare triple {13923#(<= main_~i~0 16)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13924#(<= main_~i~0 17)} is VALID [2018-11-23 12:13:10,114 INFO L273 TraceCheckUtils]: 23: Hoare triple {13924#(<= main_~i~0 17)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13925#(<= main_~i~0 18)} is VALID [2018-11-23 12:13:10,115 INFO L273 TraceCheckUtils]: 24: Hoare triple {13925#(<= main_~i~0 18)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13926#(<= main_~i~0 19)} is VALID [2018-11-23 12:13:10,116 INFO L273 TraceCheckUtils]: 25: Hoare triple {13926#(<= main_~i~0 19)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13927#(<= main_~i~0 20)} is VALID [2018-11-23 12:13:10,117 INFO L273 TraceCheckUtils]: 26: Hoare triple {13927#(<= main_~i~0 20)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13928#(<= main_~i~0 21)} is VALID [2018-11-23 12:13:10,118 INFO L273 TraceCheckUtils]: 27: Hoare triple {13928#(<= main_~i~0 21)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13929#(<= main_~i~0 22)} is VALID [2018-11-23 12:13:10,119 INFO L273 TraceCheckUtils]: 28: Hoare triple {13929#(<= main_~i~0 22)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13930#(<= main_~i~0 23)} is VALID [2018-11-23 12:13:10,120 INFO L273 TraceCheckUtils]: 29: Hoare triple {13930#(<= main_~i~0 23)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13931#(<= main_~i~0 24)} is VALID [2018-11-23 12:13:10,121 INFO L273 TraceCheckUtils]: 30: Hoare triple {13931#(<= main_~i~0 24)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13932#(<= main_~i~0 25)} is VALID [2018-11-23 12:13:10,122 INFO L273 TraceCheckUtils]: 31: Hoare triple {13932#(<= main_~i~0 25)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13933#(<= main_~i~0 26)} is VALID [2018-11-23 12:13:10,124 INFO L273 TraceCheckUtils]: 32: Hoare triple {13933#(<= main_~i~0 26)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13934#(<= main_~i~0 27)} is VALID [2018-11-23 12:13:10,125 INFO L273 TraceCheckUtils]: 33: Hoare triple {13934#(<= main_~i~0 27)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13935#(<= main_~i~0 28)} is VALID [2018-11-23 12:13:10,126 INFO L273 TraceCheckUtils]: 34: Hoare triple {13935#(<= main_~i~0 28)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13936#(<= main_~i~0 29)} is VALID [2018-11-23 12:13:10,127 INFO L273 TraceCheckUtils]: 35: Hoare triple {13936#(<= main_~i~0 29)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13937#(<= main_~i~0 30)} is VALID [2018-11-23 12:13:10,128 INFO L273 TraceCheckUtils]: 36: Hoare triple {13937#(<= main_~i~0 30)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13938#(<= main_~i~0 31)} is VALID [2018-11-23 12:13:10,129 INFO L273 TraceCheckUtils]: 37: Hoare triple {13938#(<= main_~i~0 31)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13939#(<= main_~i~0 32)} is VALID [2018-11-23 12:13:10,130 INFO L273 TraceCheckUtils]: 38: Hoare triple {13939#(<= main_~i~0 32)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13940#(<= main_~i~0 33)} is VALID [2018-11-23 12:13:10,131 INFO L273 TraceCheckUtils]: 39: Hoare triple {13940#(<= main_~i~0 33)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13941#(<= main_~i~0 34)} is VALID [2018-11-23 12:13:10,132 INFO L273 TraceCheckUtils]: 40: Hoare triple {13941#(<= main_~i~0 34)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13942#(<= main_~i~0 35)} is VALID [2018-11-23 12:13:10,133 INFO L273 TraceCheckUtils]: 41: Hoare triple {13942#(<= main_~i~0 35)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13943#(<= main_~i~0 36)} is VALID [2018-11-23 12:13:10,134 INFO L273 TraceCheckUtils]: 42: Hoare triple {13943#(<= main_~i~0 36)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13944#(<= main_~i~0 37)} is VALID [2018-11-23 12:13:10,135 INFO L273 TraceCheckUtils]: 43: Hoare triple {13944#(<= main_~i~0 37)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13945#(<= main_~i~0 38)} is VALID [2018-11-23 12:13:10,136 INFO L273 TraceCheckUtils]: 44: Hoare triple {13945#(<= main_~i~0 38)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13946#(<= main_~i~0 39)} is VALID [2018-11-23 12:13:10,137 INFO L273 TraceCheckUtils]: 45: Hoare triple {13946#(<= main_~i~0 39)} assume !!(~i~0 < 100000);call #t~mem0 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~i~0, 4);call #t~mem1 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~i~0, 4);call write~int(#t~mem0 - #t~mem1, ~#c~0.base, ~#c~0.offset + 4 * ~i~0, 4);havoc #t~mem1;havoc #t~mem0;~i~0 := 1 + ~i~0; {13947#(<= main_~i~0 40)} is VALID [2018-11-23 12:13:10,138 INFO L273 TraceCheckUtils]: 46: Hoare triple {13947#(<= main_~i~0 40)} assume !(~i~0 < 100000); {13906#false} is VALID [2018-11-23 12:13:10,138 INFO L273 TraceCheckUtils]: 47: Hoare triple {13906#false} havoc ~x~0;~x~0 := 0; {13906#false} is VALID [2018-11-23 12:13:10,139 INFO L273 TraceCheckUtils]: 48: Hoare triple {13906#false} assume !!(~x~0 < 100000);call #t~mem5 := read~int(~#c~0.base, ~#c~0.offset + 4 * ~x~0, 4);call #t~mem3 := read~int(~#a~0.base, ~#a~0.offset + 4 * ~x~0, 4);call #t~mem4 := read~int(~#b~0.base, ~#b~0.offset + 4 * ~x~0, 4); {13906#false} is VALID [2018-11-23 12:13:10,139 INFO L256 TraceCheckUtils]: 49: Hoare triple {13906#false} call __VERIFIER_assert((if #t~mem5 == #t~mem3 - #t~mem4 then 1 else 0)); {13906#false} is VALID [2018-11-23 12:13:10,139 INFO L273 TraceCheckUtils]: 50: Hoare triple {13906#false} ~cond := #in~cond; {13906#false} is VALID [2018-11-23 12:13:10,140 INFO L273 TraceCheckUtils]: 51: Hoare triple {13906#false} assume 0 == ~cond; {13906#false} is VALID [2018-11-23 12:13:10,140 INFO L273 TraceCheckUtils]: 52: Hoare triple {13906#false} assume !false; {13906#false} is VALID [2018-11-23 12:13:10,143 INFO L134 CoverageAnalysis]: Checked inductivity of 820 backedges. 0 proven. 820 refuted. 0 times theorem prover too weak. 0 trivial. 0 not checked. [2018-11-23 12:13:10,143 INFO L300 seRefinementStrategy]: The current sequences of interpolants are not accepted, trying to find more. [2018-11-23 12:13:10,143 INFO L223 ckRefinementStrategy]: Switched to mode Z3_FP No working directory specified, using /storage/repos/ultimate/releaseScripts/default/UAutomizer-linux/z3 Starting monitored process 41 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 (exit command is (exit), workingDir is null) Waiting until toolchain timeout for monitored process 41 with z3 -smt2 -in SMTLIB2_COMPLIANT=true -t:12000 [2018-11-23 12:13:10,158 INFO L103 rtionOrderModulation]: Keeping assertion order TERMS_WITH_SMALL_CONSTANTS_FIRST [2018-11-23 12:13:10,213 INFO L249 tOrderPrioritization]: Assert order TERMS_WITH_SMALL_CONSTANTS_FIRST issued 0 check-sat command(s) [2018-11-23 12:13:10,213 INFO L250 tOrderPrioritization]: Conjunction of SSA is unsat [2018-11-23 12:13:10,233 INFO L136 AnnotateAndAsserter]: Conjunction of SSA is unsat [2018-11-23 12:13:10,234 INFO L273 TraceCheckSpWp]: Computing forward predicates...