fix algorythm

improved fix_common_blocks
fixed getModuleSymbols
2026-02-19 20:47:24 +03:00 · 2026-02-19 20:47:24 +03:00 · 2026-02-19 20:47:24 +03:00 · 2026-02-19 20:47:24 +03:00 · 2026-02-19 20:47:24 +03:00 · 2026-02-19 20:47:24 +03:00
32 changed files with 1646 additions and 249 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -78,3 +78,4 @@ Sapfor/Sapc++/x64/

 Sapfor/out/
 Sapfor/_bin/*
+_bin/*
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -207,7 +207,9 @@ set(TR_EXPR_TRANSFORM src/Transformations/ExpressionSubstitution/control_flow_gr
 set(TR_INLINER src/Transformations/FunctionInlining/inliner.cpp
        src/Transformations/FunctionInlining/inliner.h)
 set(TR_RENAME_SYMBOLS  src/Transformations/RenameSymbols/rename_symbols.cpp
-                    src/Transformations/RenameSymbols/rename_symbols.h)
+        src/Transformations/RenameSymbols/rename_symbols.h)
+SET(TR_MOVE_OPERATORS src/Transformations/MoveOperators/move_operators.cpp
+        src/Transformations/MoveOperators/move_operators.h)

 set(TRANSFORMS 
        ${TR_DEAD_CODE}
@@ -230,7 +232,8 @@ set(TRANSFORMS
        ${TR_REPLACE_ARRAYS_IN_IO}
        ${TR_EXPR_TRANSFORM}
        ${TR_INLINER}
-        ${TR_RENAME_SYMBOLS})
+        ${TR_RENAME_SYMBOLS}
+        ${TR_MOVE_OPERATORS})
        
 set(CFG src/CFGraph/IR.cpp
        src/CFGraph/IR.h
@@ -464,6 +467,7 @@ source_group (Transformations\\GlobalVariables FILES ${TR_GV})
 source_group (Transformations\\ConvertToC FILES ${TR_CONV})
 source_group (Transformations\\SetImplicitNone FILES ${TR_IMPLICIT_NONE})
 source_group (Transformations\\ReplaceArraysInIO FILES ${TR_REPLACE_ARRAYS_IN_IO})
+source_group (Transformations\\MoveOperators FILES ${TR_MOVE_OPERATORS})


 source_group (CreateIntervals FILES ${CREATE_INTER_T})
--- a/projects/dvm
+++ b/projects/dvm
--- a/projects/libpredictor
+++ b/projects/libpredictor
--- a/src/ArrayConstantPropagation/propagation.cpp
+++ b/src/ArrayConstantPropagation/propagation.cpp
@@ -10,6 +10,7 @@
 using namespace std;

 static SgStatement* declPlace = NULL;
+static unordered_set<SgStatement*> changed;;

 static bool CheckConstIndexes(SgExpression* exp)
 {
@@ -36,13 +37,13 @@ static bool CheckConstIndexes(SgExpression* exp)

 static SgExpression* CreateVar(int& variableNumber, SgType* type)
 {
-    string varName = "__tmp_prop_var";
+    string varName = "tmp_prop_var";
    string name = varName + std::to_string(variableNumber) + "__";
    variableNumber++;

    SgSymbol* varSymbol = new SgSymbol(VARIABLE_NAME, name.c_str(), *type, *declPlace->controlParent());

-    const string commonBlockName = "__propagation_common__";
+    const string commonBlockName = "propagation_common__";

    SgStatement* funcStart = declPlace->controlParent();
    SgStatement* commonStat = NULL;
@@ -169,8 +170,7 @@ static SgExpression* CreateVar(int& variableNumber, SgType* type)

        commonList->setLhs(varList);
    }
-
-    return new SgExpression(VAR_REF, NULL, NULL, varSymbol, type->copyPtr());
+    return  new SgExpression(VAR_REF, NULL, NULL, varSymbol, type->copyPtr());
 }

 static void TransformRightPart(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber) 
@@ -227,6 +227,8 @@ static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<
 {
    if (exp->symbol()->type()->variant() == T_STRING)
        return;
+    if (changed.find(st) != changed.end())
+        return;
    string expUnparsed = exp->unparse();
    if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
    {
@@ -234,12 +236,62 @@ static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<
    }
    SgStatement* newStatement = new SgStatement(ASSIGN_STAT, NULL, NULL, arrayToVariable[expUnparsed]->copyPtr(), st->expr(1)->copyPtr(), NULL);

-    newStatement->setFileId(st->getFileId());
+   newStatement->setFileId(st->getFileId());
    newStatement->setProject(st->getProject()); 

    newStatement->setlineNumber(getNextNegativeLineNumber());
    newStatement->setLocalLineNumber(st->lineNumber());
    st->insertStmtBefore(*newStatement, *st->controlParent());
+    changed.insert(st);
+}
+
+static void TransformBorder(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber)
+{
+    SgStatement* firstStatement = declPlace->lexPrev();
+    st = st->lexPrev();
+    string array = exp->unparse();
+    arrayToVariable[array] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
+    while (st != firstStatement)
+    {
+        if (st->variant() == ASSIGN_STAT && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
+        {
+            if (st->expr(1))
+            {
+                TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
+            }
+            if (st->expr(0) && st->expr(0)->variant() == ARRAY_REF && CheckConstIndexes(st->expr(0)->lhs()) && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
+            {
+                TransformLeftPart(st, st->expr(0), arrayToVariable, variableNumber);
+            }
+        }
+        st = st->lexPrev();
+    }
+}
+
+static void CheckVariable(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber)
+{
+    SgStatement* firstStatement = declPlace->lexPrev();
+    st = st->lexPrev();
+    string varName = exp->unparse();
+    while (st != firstStatement)
+    {
+        if (st->variant() == ASSIGN_STAT && st->expr(0)->symbol() == exp->symbol())
+        {
+            TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
+        }
+        if (st->variant() == ASSIGN_STAT && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
+        {
+            if (st->expr(1))
+            {
+                TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
+            }
+            if (st->expr(0) && st->expr(0)->variant() == ARRAY_REF && CheckConstIndexes(st->expr(0)->lhs()) && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
+            {
+                TransformLeftPart(st, st->expr(0), arrayToVariable, variableNumber);
+            }
+        }
+        st = st->lexPrev();
+    }
 }

 void ArrayConstantPropagation(SgProject& project) 
@@ -262,40 +314,29 @@ void ArrayConstantPropagation(SgProject& project)

            for (; st != lastNode; st = st->lexNext())
            {
-                if (st->variant() == ASSIGN_STAT)
-                {
-                    if (st->expr(1))
-                    {
-                        TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
-                    }
-                    if (st->expr(0) && st->expr(0)->variant() == ARRAY_REF && CheckConstIndexes(st->expr(0)->lhs()))
-                    {
-                        TransformLeftPart(st, st->expr(0), arrayToVariable, variableNumber);
-                    }
-                }
-                else if (st->variant() == FOR_NODE)
+                if (st->variant() == FOR_NODE)
                {
                    SgExpression* lowerBound = st->expr(0)->lhs();
                    SgExpression* upperBound = st->expr(0)->rhs();
                    string lowerBoundUnparsed = lowerBound->unparse(), upperBoundUnparsed = upperBound->unparse();
                    if (upperBound->variant() == ARRAY_REF && upperBound->symbol()->type()->baseType() && CheckConstIndexes(upperBound->lhs()))
                    {
-                        if (arrayToVariable.find(upperBoundUnparsed) == arrayToVariable.end())
-                        {
-                            arrayToVariable[upperBoundUnparsed] = CreateVar(variableNumber, upperBound->symbol()->type()->baseType());
-                        }
+                        TransformBorder(st, upperBound, arrayToVariable, variableNumber);
                        st->expr(0)->setRhs(arrayToVariable[upperBoundUnparsed]->copyPtr());
                    }
+                    else if (upperBound->variant() == VAR_REF)
+                        CheckVariable(st, upperBound, arrayToVariable, variableNumber);
+
                    if (lowerBound->variant() == ARRAY_REF && lowerBound->symbol()->type()->baseType() && CheckConstIndexes(lowerBound->lhs()))
                    {
-                        if (arrayToVariable.find(lowerBoundUnparsed) == arrayToVariable.end())
-                        {
-                            arrayToVariable[lowerBoundUnparsed] = CreateVar(variableNumber, lowerBound->symbol()->type()->baseType());
-                        }
+                        TransformBorder(st, lowerBound, arrayToVariable, variableNumber);
                        st->expr(0)->setLhs(arrayToVariable[lowerBoundUnparsed]->copyPtr());
                    }
+                    else if (lowerBound->variant() == VAR_REF)
+                        CheckVariable(st, lowerBound, arrayToVariable, variableNumber);
                }
            }
+            cout << file->functions(i)->unparse() << endl;
        }
    }
 }
--- a/src/CFGraph/CFGraph.cpp
+++ b/src/CFGraph/CFGraph.cpp
@@ -1162,8 +1162,9 @@ map<FuncInfo*, vector<BBlock*>> buildCFG(const map<string, CommonBlock*>& common
    if (SgFile::switchToFile(oldFile) == -1)
        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);

-    for (auto& [func, blocks] : result)
-        removedUnreachableBlocks(blocks);
+    if (!settings.withUnreachable) 
+        for (auto& [func, blocks] : result)
+            removedUnreachableBlocks(blocks);

    return result;
 }
--- a/src/CFGraph/CFGraph.h
+++ b/src/CFGraph/CFGraph.h
@@ -105,23 +105,52 @@ namespace SAPFOR

    struct CFG_Settings
    {
+        enum setting { CFG_atLeastOneIterInLoop = 1, 
+                       CFG_withRD = 2, 
+                       CFG_withRegisters = 3,  
+                       CFG_withSPF = 4, 
+                       CFG_withDVM = 5, 
+                       CFG_withCallsInBlocks = 6, 
+                       CFG_withCallFrom = 7, 
+                       CFG_withDominators = 8, 
+                       CFG_withUnreachable = 9 };
+
        bool atLeastOneIterInLoop = false;
-        bool withRD = true;
-        bool withRegisters = false;
-        bool withSPF = false;
-        bool withDVM = false;
-        bool withCallsInBlocks = false; // separate each F_CALL to own BasicBlock
-        bool withCallFrom = true;
-        bool withDominators = true;
+        bool withRD =               false;
+        bool withRegisters =        false;
+        bool withSPF =              false;
+        bool withDVM =              false;
+        bool withCallsInBlocks =    false; // separate each F_CALL to own BasicBlock
+        bool withCallFrom =         false;
+        bool withDominators =       false;
+        bool withUnreachable =      false;

-        explicit CFG_Settings(int) { }
-
-        explicit CFG_Settings(bool atLeastOneIterInLoop = false, bool withRD = true, bool withRegisters = false, 
-                              bool withDVM = false, bool withSPF = false, bool withCallsInBlocks = false, 
-                              bool withCallFrom = true, bool withDominators = true) :
-            atLeastOneIterInLoop(atLeastOneIterInLoop), withRD(withRD), withRegisters(withRegisters), withDVM(withDVM), withSPF(withSPF), 
-            withCallsInBlocks(withCallsInBlocks), withCallFrom(withCallFrom), withDominators(withDominators)
-        { }
+        explicit CFG_Settings(const std::set<setting> &settings = { CFG_withRD, CFG_withCallFrom, CFG_withDominators })
+        {
+            for (auto& set : settings)
+            {
+                if (set == CFG_atLeastOneIterInLoop)
+                    atLeastOneIterInLoop = true;
+                else if (set == CFG_withRD)
+                    withRD = true;
+                else if (set == CFG_withRegisters)
+                    withRegisters = true;
+                else if (set == CFG_withSPF)
+                    withSPF = true;
+                else if (set == CFG_withDVM)
+                    withDVM = true;
+                else if (set == CFG_withCallsInBlocks)
+                    withCallsInBlocks = true;
+                else if (set == CFG_withCallFrom)
+                    withCallFrom = true;
+                else if (set == CFG_withDominators)
+                    withDominators = true;
+                else if (set == CFG_withUnreachable)
+                    withUnreachable = true;
+                else
+                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+            }
+        }
    };
 }

--- a/src/CFGraph/private_variables_analysis.cpp
+++ b/src/CFGraph/private_variables_analysis.cpp
@@ -200,20 +200,46 @@ static void fillOutForFunc(const FuncInfo* func, const vector<SAPFOR::BasicBlock
    outForFunc[func->funcName] = { defined, common_defined };
 }

-static void getDefsFromBlock(SAPFOR::BasicBlock* block, set<SAPFOR::Argument*>& res, 
+static bool isInstructionSpfParameter(SAPFOR::Instruction* instr)
+{
+    SgStatement* st = instr->getOperator();
+
+    // check if this operator is SPF(ANALYSIS(PARAMETER( )))
+    if (st && st->variant() == ASSIGN_STAT)
+    {
+        if (st->lineNumber() < 0 && st->numberOfAttributes())
+        {
+            for (int i = 0; i < st->numberOfAttributes(); ++i)
+            {
+                SgAttribute* attr = st->getAttribute(i);
+                SgStatement* attributeStatement = (SgStatement*)(attr->getAttributeData());
+                int type = st->attributeType(i);
+
+                if (type == SPF_PARAMETER_OP)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+
+static void getDefsFromBlock(SAPFOR::BasicBlock* block, set<SAPFOR::Argument*>& res,
                             const vector<pair<const Variable*, CommonBlock*>>& commonVars,
                             const FuncInfo* func)
 {
    vector<SAPFOR::Argument*> lastParamRef;

-    for (auto ir_block : block->getInstructions())
+    for (const auto &ir_block : block->getInstructions())
    {
        SAPFOR::Instruction* instr = ir_block->getInstruction();
+        if (isInstructionSpfParameter(instr))
+            continue;
+
        SAPFOR::CFG_OP instr_operation = instr->getOperation();
        if (instr_operation == SAPFOR::CFG_OP::PARAM)
        {
            SAPFOR::Argument* arg = instr->getArg1();
-            if(arg->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
+            if (arg->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
                addPlaceWithDef(commonVars, func, arg, instr);

            lastParamRef.push_back(arg);
@@ -236,12 +262,20 @@ static void getDefsFromBlock(SAPFOR::BasicBlock* block, set<SAPFOR::Argument*>&
    int last_instr_num = block->getInstructions().back()->getNumber();

    for (const auto& def : block->getRD_Out())
+    {
        for (int place : def.second)
+        {
            if (place >= first_instr_num && place <= last_instr_num && def.first->getType() == SAPFOR::CFG_ARG_TYPE::VAR)
            {
+                SAPFOR::Instruction* instr = block->getInstructions()[place - first_instr_num]->getInstruction();
+                if (isInstructionSpfParameter(instr))
+                    continue;
+
                res.insert(def.first);
-                addPlaceWithDef(commonVars, func, def.first, block->getInstructions()[place - first_instr_num]->getInstruction());
+                addPlaceWithDef(commonVars, func, def.first, instr);
            }
+        }
+    }
 }

 // recursively analyze FOR loops 
@@ -266,7 +300,7 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
    SAPFOR::BasicBlock* head_block = NULL;

    int loop_start = loop->lineNum, loop_end = loop->lineNumAfterLoop;
-    for (auto bb : blocks)
+    for (const auto &bb : blocks)
    {
        if (!bb || (bb->getInstructions().size() == 0))
            continue;
@@ -287,6 +321,12 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
        }
    }

+    if (currentLoop.empty()) // can't find loop IR - loop unreachable!
+    {
+        __spf_print(1, "Unreachable loop on %s:%d\n", current_file->filename(), loop_operator->lineNumber());
+        return currentLoop;
+    }
+
    if (!head_block)
        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
    
@@ -348,7 +388,7 @@ static set<SAPFOR::BasicBlock*> analyzeLoop(LoopGraph* loop, const set<SAPFOR::B
        getDefsFromBlock(*loop_it, changeValueOnExit, commonVars, func);


-    for (auto bb : currentLoop)
+    for (const auto &bb : currentLoop)
    {
        //fill LiveWhenLoopEnds
        bool has_next_outside_body = false;
--- a/src/DirectiveProcessing/insert_directive.cpp
+++ b/src/DirectiveProcessing/insert_directive.cpp
@@ -853,12 +853,21 @@ static pair<string, string> getModuleRename(const set<SgStatement*>& allocatable
        return make_pair("", "");
 }

+static void doRename(string& str, const pair<string, string>& renamePair)
+{
+    auto it = str.find(renamePair.first);
+    if (it != string::npos)
+        if (str[it + renamePair.first.size()] == '(' && str[it - 1] == ' ')
+            str = str.replace(it, renamePair.first.size(), renamePair.second);
+}
+
 static pair<DIST::Array*, string>
 getNewDirective(const string &fullArrayName, 
                const vector<string> &distrRules,
                const vector<string> &alignRules,
                const DataDirective &dataDir,
-                const set<SgStatement*>& allocatableStmts)
+                const set<SgStatement*>& allocatableStmts,
+                const pair<string, int>& position_decl)
 {
    string out = "";
    DIST::Array* outA = NULL;
@@ -877,7 +886,8 @@ getNewDirective(const string &fullArrayName,

    for (int i = 0; i < dataDir.alignRules.size(); ++i)
    {
-        if (dataDir.alignRules[i].alignArray->GetName() == fullArrayName)
+        auto alignArray = dataDir.alignRules[i].alignArray;
+        if (alignArray->GetName() == fullArrayName)
        {
            string rule = alignRules[i];
            if (allocatableStmts.size())
@@ -889,21 +899,21 @@ getNewDirective(const string &fullArrayName,
                    it = rule.find("ALIGN", it + 7);
                }
                
-                auto renamePair = getModuleRename(allocatableStmts, dataDir.alignRules[i].alignArray);
-                if (renamePair.first != "")
-                {
-                    it = rule.find(renamePair.first);
-                    if (it != string::npos)
-                        if (rule[it + renamePair.first.size()] == '(' && rule[it - 1] == ' ')
-                            rule = rule.replace(it, renamePair.first.size(), renamePair.second);
-                }
+                auto renamePair = getModuleRename(allocatableStmts, alignArray);
+                doRename(rule, renamePair);
+            }
+            else if (alignArray->GetLocation().first == DIST::l_COMMON)
+            {
+                auto symb = alignArray->GetDeclSymbol(position_decl);
+                if (symb->identifier() != alignArray->GetShortName())
+                    doRename(rule, make_pair(alignArray->GetShortName(), symb->identifier()));
            }

            out += "!DVM$ " + rule + "\n";
            if (!out_free_form)
                out = splitDirective(out);

-            return make_pair(dataDir.alignRules[i].alignArray, out);
+            return make_pair(alignArray, out);
        }
    }
    
@@ -1743,7 +1753,7 @@ void insertDistributionToFile(SgFile *file, const char *fin_name, const DataDire
                            if (allocatableStmtsCopy.size())
                                allocatableStmts = filterAllocateStats(file, allocatableStmtsCopy, currSymb->identifier());
   
-                            pair<DIST::Array*, string> dirWithArray = getNewDirective(fullArrayName, distrRules, alignRules, dataDir, allocatableStmts);
+                            pair<DIST::Array*, string> dirWithArray = getNewDirective(fullArrayName, distrRules, alignRules, dataDir, allocatableStmts, make_pair(st->fileName(), st->lineNumber()));

                            string toInsert = dirWithArray.second;
                            if (toInsert != "")
@@ -1975,20 +1985,27 @@ void insertDistributionToFile(SgFile *file, const char *fin_name, const DataDire
                set<string> toInsertArrays;
                for (auto &array : dynamicArraysLocal)
                {
+                    string name = array->GetShortName();
+                    if (array->GetLocation().first == DIST::l_COMMON)
+                    {
+                        auto symb = array->GetDeclSymbol(make_pair(st->fileName(), st->lineNumber()));
+                        name = symb->identifier();
+                    }
+
                    if (extractDir)
                    {
-                        if (dynamicArraysAdded.find(array->GetShortName()) != dynamicArraysAdded.end())
+                        if (dynamicArraysAdded.find(name) != dynamicArraysAdded.end())
                        {
-                            dynamicArraysAdded.erase(array->GetShortName());
-                            toInsertArrays.insert(array->GetShortName());
+                            dynamicArraysAdded.erase(name);
+                            toInsertArrays.insert(name);
                        }
                    }
                    else
                    {
-                        if (dynamicArraysAdded.find(array->GetShortName()) == dynamicArraysAdded.end())
+                        if (dynamicArraysAdded.find(name) == dynamicArraysAdded.end())
                        {
-                            dynamicArraysAdded.insert(array->GetShortName());
-                            toInsertArrays.insert(array->GetShortName());
+                            dynamicArraysAdded.insert(name);
+                            toInsertArrays.insert(name);
                        }
                    }
                }
@@ -2145,7 +2162,14 @@ void insertShadowSpecToFile(SgFile *file, const char *fin_name, const set<string

                    if (needToGen)
                    {
-                        string shadowSpecInsert = "!DVM$ SHADOW " + array->GetShortName() + "(";
+                        string name = array->GetShortName();
+                        if (array->GetLocation().first == DIST::l_COMMON)
+                        {
+                            auto symb = array->GetDeclSymbol(make_pair(st->fileName(), st->lineNumber()));
+                            name = symb->identifier();
+                        }
+
+                        string shadowSpecInsert = "!DVM$ SHADOW " + name + "(";
                        for (int k = 0; k < currSpec.size(); ++k)
                        {
                            char buf[256];
@@ -2157,7 +2181,7 @@ void insertShadowSpecToFile(SgFile *file, const char *fin_name, const set<string
                        shadowSpecInsert += ")\n";

                        shadowsSpecsString.push_back(shadowSpecInsert);
-                        pair<SgExpression*, SgExpression*> newSpec = genShadowSpec(file, make_pair(array->GetShortName(), currSpec));
+                        pair<SgExpression*, SgExpression*> newSpec = genShadowSpec(file, make_pair(name, currSpec));
                        if (newSpec.first == NULL || newSpec.second == NULL)
                            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
                        shadowsSpecs.push_back(newSpec);
--- a/src/DirectiveProcessing/shadow.cpp
+++ b/src/DirectiveProcessing/shadow.cpp
@@ -26,6 +26,7 @@ using std::string;
 using std::vector;
 using std::pair;
 using std::make_pair;
+using SAPFOR::CFG_Settings;

 extern int debSh;

@@ -1672,9 +1673,12 @@ void GroupShadow(const map<string, vector<FuncInfo*>>& allFuncs,
        
            SgStatement* func = currF->funcPointer->GetOriginal();

-            auto cfg = buildCFGforCurrentFunc(func, SAPFOR::CFG_Settings(true, false, false, true, false, true, false), commonBlocks, allFuncs);
+            const auto settings = CFG_Settings({ CFG_Settings::CFG_atLeastOneIterInLoop, CFG_Settings::CFG_withDVM, 
+                                                 CFG_Settings::CFG_withCallsInBlocks, CFG_Settings::CFG_withUnreachable });
+            auto cfg = buildCFGforCurrentFunc(func, settings, commonBlocks, allFuncs);
            if (cfg.size() != 1)
                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
            auto& blocks = cfg.begin()->second;

            //create reaching blocks
--- a/src/Distribution/Array.h
+++ b/src/Distribution/Array.h
@@ -336,9 +336,24 @@ namespace Distribution
            if (pos != STRING::npos)
            {
                name.erase(pos, shortName.size());
-                shortName = newName;
                name += newName;
            }
+            else if (locationPos.first == l_COMMON) // name of array in common may be different
+            {
+                pos = name.rfind("_");
+                if (pos != STRING::npos)
+                {
+                    name.erase(pos + 1, shortName.size());
+                    name += newName;
+                }
+                else
+                {
+#if __SPF
+                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+#endif
+                }
+            }
+            shortName = newName;
            GenUniqKey();
        }

@@ -542,6 +557,44 @@ namespace Distribution
            return NULL; 
        }

+        Symbol* GetDeclSymbol(const PAIR<STRING, int>& position_decl) const
+        {
+            if (!IsArray() || locationPos.first != l_COMMON)
+                return declSymbol;
+
+            auto it = declPlacesSymbol.find(position_decl);
+            if (it != declPlacesSymbol.end())
+                return it->second;
+            else // find nearest
+            {
+                MAP<PAIR<STRING, int>, Symbol*> currFile;
+                for (auto& [position, symb] : declPlacesSymbol)
+                {
+                    if (position.first == position_decl.first)
+                        currFile[position] = symb;
+                }
+
+                PAIR<int, Symbol*> nearest = { (int)0, NULL };
+                const int needed_pos = position_decl.second;
+
+                for (auto& [position, symb] : currFile)
+                {
+                    if (nearest.second == NULL)
+                        nearest = { abs(position.second - needed_pos), symb };
+
+                    if (abs(position.second - needed_pos) < nearest.first)
+                        nearest = { abs(position.second - needed_pos), symb };
+                }
+
+                if (nearest.second)
+                    return nearest.second;
+#if __SPF
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+#endif
+            }
+            return NULL;
+        }
+
        Symbol* GetDeclSymbol() const { return declSymbol; }
        void SetDeclSymbol(Symbol *s) { declSymbol = s; }

--- a/src/Predictor/PredictScheme.cpp
+++ b/src/Predictor/PredictScheme.cpp
@@ -33,6 +33,7 @@ using std::set;
 using std::ofstream;
 using std::pair;
 using std::tuple;
+using SAPFOR::CFG_Settings;

 using json = nlohmann::json;

@@ -507,7 +508,8 @@ static void parallelDir(const map<DIST::Array*, int>& byPos, SgExpression* spec,
    if (currF == NULL)
        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);

-    auto cfg = buildCFGforCurrentFunc(func, SAPFOR::CFG_Settings(true, false, false, true, false, false, true), commonBlocks, allFuncInfo);
+    const auto settings = CFG_Settings({ CFG_Settings::CFG_atLeastOneIterInLoop, CFG_Settings::CFG_withSPF, CFG_Settings::CFG_withDominators });
+    auto cfg = buildCFGforCurrentFunc(func, settings, commonBlocks, allFuncInfo);
    //TODO IP analysis
        
    unsigned countOfAccess = 0;
--- a/src/PrivateAnalyzer/private_arrays_search.cpp
+++ b/src/PrivateAnalyzer/private_arrays_search.cpp
@@ -1,3 +1,4 @@
+#include <algorithm>
 #include <map>
 #include <unordered_set>
 #include <unordered_map>
@@ -16,6 +17,8 @@

 using namespace std;

+static unordered_set<Region*> collapsed;
+
 static void RemoveEmptyPoints(ArrayAccessingIndexes& container)
 {
    ArrayAccessingIndexes resultContainer;
@@ -49,41 +52,81 @@ static void Collapse(Region* region)
    if (region->getBasickBlocks().empty())
        return;

-    for (auto& [arrayName, arrayRanges] : region->getHeader()->array_out)
+    bool firstRegion = true;
+    for (Region* basickBlock : region->getBasickBlocks())
    {
-        for (Region* byBlock : region->getBasickBlocks())
+        if (basickBlock->getNextRegions().empty())
        {
-            AccessingSet intersection = byBlock->array_def[arrayName].Intersect(arrayRanges);
-            region->array_def[arrayName] = region->array_def[arrayName].Union(intersection);
+            if (firstRegion)
+            {
+                region->array_def = basickBlock->array_out;
+                firstRegion = false;
+            }
+            else
+            {
+                unordered_set<string> toErease;
+                for (auto& [arrayName, arrayRanges] : region->array_def)
+                {
+                    if (basickBlock->array_out.find(arrayName) != basickBlock->array_out.end())
+                        arrayRanges = arrayRanges.Intersect(basickBlock->array_out[arrayName]);
+                    else
+                    {
+                        arrayRanges = AccessingSet();
+                        toErease.insert(arrayName);
+                    }
+                }
+                for (string arrayName : toErease)
+                    region->array_def.erase(arrayName);
+            }
        }
    }

-    for (auto& byBlock : region->getBasickBlocks()) 
-    {
-        for (auto& [arrayName, arrayRanges] : byBlock->array_use)
-        {
-            AccessingSet diff = byBlock->array_use[arrayName].Diff(byBlock->array_in[arrayName]);
-            region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
-        }
-    }
-
-    ArrayAccessingIndexes useUnion;
-    for (auto& byBlock : region->getBasickBlocks())
-        for (auto& [arrayName, arrayRanges] : byBlock->array_use)
-            useUnion[arrayName] = useUnion[arrayName].Union(byBlock->array_use[arrayName]);
-
-    region->array_priv = region->array_use;
+    RegionInstruction instruction;
+    instruction.def = move(region->array_def);
    
-    for (Region* prevBlock : region->getHeader()->getPrevRegions()) 
+
+    for (auto& byBlock : region->getBasickBlocks())
+    {
+        for (auto& instruction : byBlock->instructions)
+        {
+            for (auto& [arrayName, _] : instruction.use)
+            {
+                AccessingSet diff = instruction.use[arrayName].Diff(instruction.in[arrayName]);
+                region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
+            }
+        }
+    }
+
+    ArrayAccessingIndexes useUnionB;
+    for (auto& byBlock : region->getBasickBlocks())
+        for (auto& instruction : byBlock->instructions)
+            for (auto& [arrayName, _] : instruction.use)
+                useUnionB[arrayName] = useUnionB[arrayName].Union(instruction.use[arrayName]);
+
+    for (auto& [arrayName, _] : useUnionB)
+        region->array_priv[arrayName] = useUnionB[arrayName].Diff(region->array_use[arrayName]);
+
+    instruction.use = move(region->array_use);
+    
+    for (Region* prevBlock : region->getHeader()->getPrevRegions())
+    {
        prevBlock->replaceInNextRegions(region, region->getHeader());
+        region->addPrevRegion(prevBlock);
+    }
    
    for (Region* nextBlock : region->getHeader()->getNextRegions())
+    {
        nextBlock->replaceInPrevRegions(region, region->getHeader());
+        region->addNextRegion(nextBlock);
+    }
+    region->instructions.push_back(instruction);
+
 }

 static void SolveDataFlowIteratively(Region* DFG) 
 {
-    unordered_set<Region*> worklist(DFG->getBasickBlocks());
+    auto blocks = DFG->getBasickBlocks();
+    std::unordered_set<Region*> worklist(blocks.begin(), blocks.end());
    do
    {
        Region* b = *worklist.begin();
@@ -101,7 +144,7 @@ static void SolveDataFlowIteratively(Region* DFG)
                if (prevBlock->array_out.empty())
                {
                    newIn.clear();
-                    continue;
+                    break;
                }

                for (const auto& [arrayName, accessSet] : prevBlock->array_out)
@@ -141,17 +184,150 @@ static void SolveDataFlowIteratively(Region* DFG)
    while (!worklist.empty());
 }

+static void SolveForBasickBlock(Region* block)
+{
+    ArrayAccessingIndexes newIn;
+    bool flagFirst = true;
+    for (Region* prevBlock : block->getPrevRegions())
+    {
+        if (flagFirst)
+        {
+            newIn = prevBlock->array_out;
+            flagFirst = false;
+        }
+        else
+        {
+            if (prevBlock->array_out.empty())
+            {
+                newIn.clear();
+                break;
+            }
+
+            for (const auto& [arrayName, accessSet] : prevBlock->array_out)
+            {
+                if (newIn.find(arrayName) != newIn.end())
+                    newIn[arrayName] = newIn[arrayName].Intersect(accessSet);
+                else
+                    newIn[arrayName] = AccessingSet();
+            }
+        }
+    }
+
+    if (block->instructions.empty())
+        block->instructions.push_back(RegionInstruction());
+
+    block->instructions[0].in = move(newIn);
+
+    for (int i = 0; i < block->instructions.size(); i++)
+    {
+        auto& instruction = block->instructions[i];
+
+        if (i > 0)
+            instruction.in = block->instructions[i - 1].out;
+
+        ArrayAccessingIndexes newOut;
+        if (instruction.def.empty())
+            newOut = instruction.in;
+        else if (instruction.in.empty())
+            newOut = instruction.def;
+        else
+        {
+            for (auto& [arrayName, accessSet] : instruction.def)
+            {
+                if (instruction.in.find(arrayName) != instruction.in.end())
+                    newOut[arrayName] = instruction.def[arrayName].Union(instruction.in[arrayName]);
+                else
+                    newOut[arrayName] = accessSet;
+            }
+            for (auto& [arrayName, accessSet] : instruction.in)
+            {
+                if (newOut.find(arrayName) == newOut.end())
+                {
+                    newOut[arrayName] = accessSet;
+                }
+            }
+        }
+
+        instruction.out = move(newOut);
+    }
+    if (!block->instructions.empty())
+        block->array_out = block->instructions.back().out;
+}
+
+static void SolveDataFlowTopologically(Region* DFG)
+{
+    for (Region* b : DFG->getBasickBlocks())
+    {
+        collapsed.insert(b);
+        SolveForBasickBlock(b);
+    }
+}
+
 static void SolveDataFlow(Region* DFG)
 {
    if (!DFG)
        return;
-
-    SolveDataFlowIteratively(DFG);
    for (Region* subRegion : DFG->getSubRegions())
+    {
        SolveDataFlow(subRegion);
+        DFG->addBasickBlocks(subRegion);
+    }
+    vector<Region*>& blocks = DFG->getBasickBlocks();
+    auto pos = remove_if(blocks.begin(), blocks.end(), [](Region* r) { return collapsed.find(r) != collapsed.end(); });
+    blocks.erase(pos, blocks.end());
+    TopologySort(DFG->getBasickBlocks(), DFG->getHeader());
+    SolveDataFlowTopologically(DFG);
    Collapse(DFG);
 }

+static bool getArrayDeclaredDimensions(SgArrayRefExp* arrayRef, vector<uint64_t>& declaredDims)
+{
+    declaredDims.clear();
+    if (!arrayRef || !arrayRef->symbol() || !isSgArrayType(arrayRef->symbol()->type()))
+        return false;
+    SgArrayType* arrayType = (SgArrayType*)arrayRef->symbol()->type();
+    int dimCount = arrayType->dimension();
+    for (int i = 0; i < dimCount; i++)
+    {
+        SgExpression* sizeExpr = arrayType->sizeInDim(i);
+        SgConstantSymb* constValSymb = isSgConstantSymb(sizeExpr->symbol());
+        string strDimLength;
+        if (sizeExpr && sizeExpr->variant() == INT_VAL)
+            strDimLength = sizeExpr->unparse();
+        else if (constValSymb)
+            strDimLength = constValSymb->constantValue()->unparse();
+        else
+            return false;
+
+        if (strDimLength == "0")
+            return false;
+        declaredDims.push_back((uint64_t)stoi(strDimLength));
+    }
+    return true;
+}
+
+static bool CheckDimensionLength(const AccessingSet& array)
+{
+    if (array.GetElements().empty())
+        return false;
+    size_t dimCount = array.GetElements()[0].size();
+    SgArrayRefExp* arrayRef = array.GetElements()[0][0].array;
+    if (!arrayRef)
+        return false;
+    vector<uint64_t> declaredDims(dimCount);
+    if (!getArrayDeclaredDimensions(arrayRef, declaredDims))
+        return false;
+    vector<ArrayDimension> testArray(dimCount);
+    for (size_t i = 0; i < dimCount; i++)
+    {
+        testArray[i] = { 1, 1, declaredDims[i], nullptr };
+    }
+    AccessingSet diff = AccessingSet({ testArray }).Diff(array);
+
+    return diff.GetElements().empty();
+}
+
+
 static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes& privates, set<SgStatement*>& insertedPrivates)
 {
    SgStatement* spfStat = new SgStatement(SPF_ANALYSIS_DIR);
@@ -161,6 +337,8 @@ static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes&
    set<SgSymbol*> arraysToInsert;
    for (const auto& [_, accessingSet] : privates)
    {
+        if (!CheckDimensionLength(accessingSet))
+            continue;
        for (const auto& arrayElement : accessingSet.GetElements())
        {
            if (arrayElement.empty())
@@ -188,11 +366,11 @@ static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes&
        toAdd->setLhs(new SgVarRefExp(elem));
    }
    
-    if (arraysToInsert.size() == 0)
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-    loop->loop->insertStmtBefore(*spfStat, *loop->loop->controlParent());
-    insertedPrivates.insert(spfStat);
+    if (arraysToInsert.size() != 0)
+    {
+        loop->loop->insertStmtBefore(*spfStat, *loop->loop->controlParent());
+        insertedPrivates.insert(spfStat);
+    }
 }

 void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, set<SgStatement*> &insertedPrivates)
--- a/src/PrivateAnalyzer/range_structures.cpp
+++ b/src/PrivateAnalyzer/range_structures.cpp
@@ -132,8 +132,10 @@ static vector<ArrayDimension> ElementsIntersection(const vector<ArrayDimension>&
 static vector<vector<ArrayDimension>> ElementsDifference(const vector<ArrayDimension>& firstElement,
    const vector<ArrayDimension>& secondElement)
 {
-    if (firstElement.empty() || secondElement.empty())
+    if (firstElement.empty())
        return {};
+    if (secondElement.empty())
+        return { firstElement };
    
    vector<ArrayDimension> intersection = ElementsIntersection(firstElement, secondElement);
    vector<vector<ArrayDimension>> result;
@@ -188,7 +190,7 @@ bool AccessingSet::ContainsElement(const vector<ArrayDimension>& element) const
 {
    vector<vector<ArrayDimension>> tails;
    FindUncovered(element, tails);
-    return !tails.empty();
+    return tails.empty();
 }

 void AccessingSet::FindCoveredBy(const vector<ArrayDimension>& element, vector<vector<ArrayDimension>>& result) const
@@ -252,13 +254,15 @@ AccessingSet AccessingSet::Diff(const AccessingSet& secondSet) const
        return *this;

    AccessingSet intersection = this->Intersect(secondSet);
-    AccessingSet uncovered = *this;
-    vector<vector<ArrayDimension>> result;
-    for (const auto& element : intersection.GetElements())
+    vector<vector<ArrayDimension>> uncovered;
+    for (const auto& element : allElements)
    {
        vector<vector<ArrayDimension>> current_uncovered;
-        uncovered.FindUncovered(element, current_uncovered);
-        uncovered = AccessingSet(current_uncovered);
+        intersection.FindUncovered(element, current_uncovered);
+        uncovered.insert(uncovered.end(),
+            std::move_iterator(current_uncovered.begin()),
+            std::move_iterator(current_uncovered.end())
+        );
    }
    return uncovered;
 }
--- a/src/PrivateAnalyzer/region.cpp
+++ b/src/PrivateAnalyzer/region.cpp
@@ -1,14 +1,16 @@
-#include<vector>
-#include<map>
-#include<unordered_set>
-#include<unordered_map>
-#include<string>
+#include <algorithm>
+#include <vector>
+#include <map>
+#include <unordered_set>
+#include <unordered_map>
+#include <string>
 #include <numeric>
 #include <iostream>

 #include "range_structures.h"
 #include "region.h"

+#include "..\Transformations\ExpressionSubstitution\expr_transform.h"
 #include "SgUtils.h"

 using namespace std;
@@ -93,7 +95,7 @@ static string FindIndexName(int pos, SAPFOR::BasicBlock* block, map<string, Loop
    return "";
 }

-static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAccessingIndexes& def, ArrayAccessingIndexes& use) {
+static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAccessingIndexes& def, ArrayAccessingIndexes& use, ArrayAccessingIndexes& all_use, Region* region) {
    auto instructions = block->getInstructions();
    map<string, LoopGraph*> loopForIndex;
    BuildLoopIndex(loopForIndex, loop);
@@ -123,7 +125,11 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                    }

                    if (point.size() == dimCount)
-                        def[instruction->getInstruction()->getResult()->getValue()] = AccessingSet({point});
+                    {
+                        def[instruction->getInstruction()->getResult()->getValue()] = AccessingSet({ point });
+                        RegionInstruction regionInstruction;
+                        regionInstruction.def[instruction->getInstruction()->getResult()->getValue()] = AccessingSet({ point });
+                    }
                }
            }
        }
@@ -131,7 +137,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
        {
            vector<SAPFOR::Argument*> index_vars;
            vector<int> refPos;
-            string array_name = instruction->getInstruction()->getArg1()->getValue();            
+            string array_name = instruction->getInstruction()->getArg1()->getValue();

            int j = i - 1;
            while (j >= 0 && instructions[j]->getInstruction()->getOperation() == SAPFOR::CFG_OP::REF)
@@ -148,13 +154,27 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
            auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression());
            int fillCount = 0;

-            while (!index_vars.empty() && !refPos.empty())
+            vector<pair<int, int>> coeffsForDims;
+            int subs = ref->numberOfSubscripts();
+            for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i)
+            {
+                const vector<int*>& coeffs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
+                if (coeffs.size() == 1)
+                {
+                    const pair<int, int> coef(coeffs[0][0], coeffs[0][1]);
+                    coeffsForDims.push_back(coef);
+                }
+
+            }
+            coeffsForDims = {coeffsForDims.rbegin(), coeffsForDims.rend()};
+
+            while (!index_vars.empty() && !refPos.empty() && !coeffsForDims.empty())
            {
                auto var = index_vars.back();
                int currentVarPos = refPos.back();
                ArrayDimension current_dim;
                if (var->getType() == SAPFOR::CFG_ARG_TYPE::CONST)
-                    current_dim = { stoul(var->getValue()), 1, 1, ref};
+                    current_dim = { stoul(var->getValue()), 1, 1, ref };
                else
                {
                    string name, full_name = var->getValue();
@@ -180,7 +200,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                            return -1;
                    }

-                    uint64_t start = currentLoop->startVal;
+                    uint64_t start = coeffsForDims.back().second * currentLoop->startVal + coeffsForDims.back().first;
                    uint64_t step = currentLoop->stepVal;
                    uint64_t iters = currentLoop->calculatedCountOfIters;
                    current_dim = { start, step, iters, ref };
@@ -193,14 +213,30 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                }
                index_vars.pop_back();
                refPos.pop_back();
+                coeffsForDims.pop_back();
            }

            if (fillCount == accessPoint.size())
            {
+                RegionInstruction instruction;
                if (operation == SAPFOR::CFG_OP::STORE)
+                {
                    def[array_name].Insert(accessPoint);
+                    instruction.def[array_name] = { { accessPoint } };
+                }
                else
-                    use[array_name].Insert(accessPoint);
+                {
+                    instruction.use[array_name] = { { accessPoint } };
+                    all_use[array_name].Insert(accessPoint);
+                    if (def.find(array_name) == def.end())
+                        use[array_name].Insert(accessPoint);
+                    else
+                    {
+                        AccessingSet element({ accessPoint });
+                        use[array_name] = use[array_name].Union(element.Diff(def[array_name]));
+                    }
+                }
+                region->instructions.push_back(instruction);
            }
        }
    }
@@ -208,6 +244,41 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces

 }

+static void RemoveHeaderConnection(SAPFOR::BasicBlock* header, const unordered_set<SAPFOR::BasicBlock*>& blockSet, unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
+{
+    for (SAPFOR::BasicBlock* block : blockSet)
+    {
+        bool isCycleBlock = false;
+        for (SAPFOR::BasicBlock* prevBlock : block->getPrev())
+            isCycleBlock = isCycleBlock || (blockSet.find(prevBlock) != blockSet.end());
+
+        if (isCycleBlock)
+        {
+            bbToRegion[block]->removeNextRegion(bbToRegion[header]);
+            bbToRegion[header]->removePrevRegion(bbToRegion[block]);
+        }
+    }
+}
+
+static void DFS(Region* block, vector<Region*>& result, unordered_set<Region*> cycleBlocks)
+{
+    for (Region* nextBlock : block->getNextRegions())
+    {
+        if (cycleBlocks.find(nextBlock) != cycleBlocks.end())
+            DFS(nextBlock, result, cycleBlocks);
+    }
+    result.push_back(block);
+}
+
+void TopologySort(std::vector<Region*>& basikBlocks, Region* header)
+{
+    vector<Region*> result;
+    unordered_set<Region*> cycleBlocks(basikBlocks.begin(), basikBlocks.end());
+    DFS(header, result, cycleBlocks);
+    reverse(result.begin(), result.end());
+    basikBlocks = result;
+}
+
 static void SetConnections(unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion, const unordered_set<SAPFOR::BasicBlock*>& blockSet)
 {
    for (SAPFOR::BasicBlock* block : blockSet)
@@ -222,10 +293,11 @@ static void SetConnections(unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegi
    }
 }

-static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks, const unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
+static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks, unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
 {
    Region* region = new Region;
    auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks);
+    RemoveHeaderConnection(header, blockSet, bbToRegion);
    if (bbToRegion.find(header) != bbToRegion.end())
        region->setHeader(bbToRegion.at(header));    
    else
@@ -237,13 +309,14 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
    for (SAPFOR::BasicBlock* block : blockSet)
        if (bbToRegion.find(block) != bbToRegion.end())
            region->addBasickBlocks(bbToRegion.at(block));
-
+    
    for (LoopGraph* childLoop : loop->children)
    {
        if (!childLoop->isFor())
            continue;
        region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion));
    }
+    TopologySort(region->getBasickBlocks(), region->getHeader());
    return region;
 }

@@ -254,12 +327,13 @@ Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
    for (auto poiner : blockSet)
    {
        bbToRegion[poiner] = new Region(*poiner);
-        this->basickBlocks.insert(bbToRegion[poiner]);
-        GetDefUseArray(poiner, loop, bbToRegion[poiner]->array_def, bbToRegion[poiner]->array_use);
+        this->basickBlocks.push_back(bbToRegion[poiner]);
+        GetDefUseArray(poiner, loop, bbToRegion[poiner]->array_def, bbToRegion[poiner]->array_use, bbToRegion[poiner]->array_all_use, bbToRegion[poiner]);

    }
    this->header = bbToRegion[header];
    SetConnections(bbToRegion, blockSet);
+    RemoveHeaderConnection(header, blockSet, bbToRegion);
    //create subRegions
    for (LoopGraph* childLoop : loop->children)
    {
@@ -267,4 +341,5 @@ Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
            continue;
        subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion));
    }
+    TopologySort(basickBlocks, this->header);
 }
--- a/src/PrivateAnalyzer/region.h
+++ b/src/PrivateAnalyzer/region.h
@@ -8,6 +8,11 @@
 #include "graph_loops.h"
 #include "CFGraph/CFGraph.h"

+struct RegionInstruction
+{
+    ArrayAccessingIndexes def, use, in, out;
+};
+
 class Region : public SAPFOR::BasicBlock {
 public:
    Region() { header = nullptr; }
@@ -20,13 +25,25 @@ public:

    void setHeader(Region* region) { header = region; }

-    std::unordered_set<Region*>& getBasickBlocks() { return basickBlocks; }
+    std::vector<Region*>& getBasickBlocks() { return basickBlocks; }

-    void addBasickBlocks(Region* region) { basickBlocks.insert(region); }
+    void addBasickBlocks(Region* region) { basickBlocks.push_back(region); }

    const std::unordered_set<Region*>& getPrevRegions() { return prevRegions; }

-    std::unordered_set<Region*> getNextRegions() { return nextRegions; }
+    std::unordered_set<Region*>& getNextRegions() { return nextRegions; }
+
+    void removeNextRegion(Region* region) 
+    {
+        if (nextRegions.find(region) != nextRegions.end())
+            nextRegions.erase(region);
+    }
+
+    void removePrevRegion(Region* region)
+    {
+        if (prevRegions.find(region) != prevRegions.end())
+            prevRegions.erase(region);
+    }

    void addPrevRegion(Region* region) { prevRegions.insert(region); }

@@ -48,13 +65,18 @@ public:

    void addSubRegions(Region* region) { subRegions.insert(region); }

-    ArrayAccessingIndexes array_def, array_use, array_out, array_in, array_priv;
+    std::vector<RegionInstruction> instructions;
+
+    ArrayAccessingIndexes array_def, array_use, array_out, array_in, array_priv, array_all_use;

 private:
-    std::unordered_set<Region*> subRegions, basickBlocks;
+    std::vector<Region*> basickBlocks;
+    std::unordered_set<Region*> subRegions;
    /*next Region which is BB for current BB Region*/
    std::unordered_set<Region*> nextRegions;
    /*prev Regions which is BBs for current BB Region*/
    std::unordered_set<Region*> prevRegions;
    Region* header;
 };
+
+void TopologySort(std::vector<Region*>& basikBlocks, Region* header);
--- a/src/Sapfor.cpp
+++ b/src/Sapfor.cpp
@@ -90,6 +90,7 @@
 #include "Transformations/DeadCodeRemoving/dead_code.h"
 #include "Transformations/RenameSymbols/rename_symbols.h"
 #include "Transformations/FunctionInlining/inliner.h"
+#include "Transformations/MoveOperators/move_operators.h"

 #include "ProjectParameters/projectParameters.h"

@@ -941,6 +942,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                    internalExit = err;
            }
        }
+        else if (curr_regime == MOVE_OPERATORS)        
+            moveOperators(file, loopGraph, fullIR, countOfTransform);        
        else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
        {
            auto itFound = loopGraph.find(file->filename());
@@ -1037,7 +1040,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                          PRIVATE_REMOVING,
                          PRIVATE_ARRAYS_EXPANSION, 
                          PRIVATE_ARRAYS_SHRINKING,
-                          REMOVE_DEAD_CODE };
+                          REMOVE_DEAD_CODE,
+                          MOVE_OPERATORS };

    if ((countOfTransform == 0 || internalExit > 0) && applyFor.find(curr_regime) != applyFor.end())
    {
@@ -1889,7 +1893,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
        findParameters(parametersOfProject, fullIR, declaredArrays);
    else if (curr_regime == BUILD_IR)
    {
-        auto CFG_forFile = buildCFG(commonBlocks, allFuncInfo_IR, SAPFOR::CFG_Settings(0));
+        auto CFG_forFile = buildCFG(commonBlocks, allFuncInfo_IR, SAPFOR::CFG_Settings());
        for (auto& byFunc : CFG_forFile)
            fullIR[byFunc.first].insert(fullIR[byFunc.first].end(), byFunc.second.begin(), byFunc.second.end());

@@ -2339,6 +2343,7 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
    case INSERT_NO_DISTR_FLAGS_FROM_GUI:
    case PRIVATE_REMOVING:
    case RENAME_INLCUDES:
+    case MOVE_OPERATORS:
        runAnalysis(*project, curr_regime, true, "", folderName);
        break;
    case INLINE_PROCEDURES:
@@ -2519,8 +2524,8 @@ int main(int argc, char **argv)
                    out_free_form = 1;
                    out_line_unlimit = 1;
                }
-                else if (string(curr_arg) == "-sh")
-                    staticShadowAnalysis = 1;
+                /*else if (string(curr_arg) == "-sh")
+                    staticShadowAnalysis = 1;*/
                else if (string(curr_arg) == "-shWidth")
                {
                    i++;
--- a/src/Sapfor.h
+++ b/src/Sapfor.h
@@ -122,6 +122,8 @@ enum passes {
    CREATE_INTER_TREE,
    INSERT_INTER_TREE,

+    MOVE_OPERATORS,
+
    SHADOW_GROUPING,
    INLINE_PROCEDURES,
    FILL_PARALLEL_REG_IR,
@@ -321,6 +323,7 @@ static void setPassValues()
    passNames[CHECK_PAR_REG_DIR] = "CHECK_PAR_REG_DIR";
    passNames[CREATE_INTER_TREE] = "CREATE_INTER_TREE";
    passNames[INSERT_INTER_TREE] = "INSERT_INTER_TREE";
+    passNames[MOVE_OPERATORS] = "MOVE_OPERATORS";
    passNames[CREATE_PARALLEL_REGIONS] = "CREATE_PARALLEL_REGIONS";
    passNames[PRIVATE_REMOVING_ANALYSIS] = "PRIVATE_REMOVING_ANALYSIS";
    passNames[PRIVATE_REMOVING] = "PRIVATE_REMOVING";
--- a/src/SapforData.h
+++ b/src/SapforData.h
@@ -19,7 +19,7 @@
 extern std::map<std::string, std::string> shortFileNames;
 static int activeState = 0;

-int staticShadowAnalysis = 0;
+int staticShadowAnalysis = 1;
 int staticPrivateAnalysis = 0;
 int keepDvmDirectives = 0;
 int keepFiles = 0;
--- a/src/Transformations/DeadCodeRemoving/dead_code.cpp
+++ b/src/Transformations/DeadCodeRemoving/dead_code.cpp
@@ -12,6 +12,7 @@ using std::map;
 using std::string;
 using std::vector;
 using std::set;
+using  SAPFOR::CFG_Settings;

 using std::remove_if;

@@ -424,7 +425,8 @@ int removeDeadCode(SgStatement* func,
        if (intervalDelEnd->lineNumber() < prog->lineNumber() || intervalDelEnd->lineNumber() > prog->lastNodeOfStmt()->lineNumber())
            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);

-    auto cfg = buildCFGforCurrentFunc(func, SAPFOR::CFG_Settings(true, false, false, false, false, false, false), commonBlocks, allFuncs);
+    const auto settings = CFG_Settings({ CFG_Settings::CFG_atLeastOneIterInLoop });
+    auto cfg = buildCFGforCurrentFunc(func, settings, commonBlocks, allFuncs);

    if(cfg.size() != 1)
        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
--- a/src/Transformations/GlobalVariables/fix_common_blocks.cpp
+++ b/src/Transformations/GlobalVariables/fix_common_blocks.cpp
@@ -18,69 +18,66 @@ using std::tuple;

 /// main function:
 // renew unions for all common blocks in the file
-static void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBlocks,
-    map<string, deque<CommConstraint>>& newCommonDecls, map<string, map<string, deque<CommConstraint>>>& commDecls,
-    set<string>& badCommon, map<string, set<string>>& notUsedVars, vector<SgStatement*>& programUnits);
+//void BuildNewCommDecls

 // get names of variables and array elements, which were referenced in programm unit
-static set<string> getUses(SgStatement* firstSt, const set<string>& commonVarNames);
-static void getUsesFromExpr(SgExpression* expr, const set<string>& commonVarNames, set<string>& used);
+//set<string> getUses
+//void getUsesFromExpr

 // splits arrays into elements and replaces not used vars with empty constraints
-static bool splitType(deque<CommConstraint>& d, bool check_use, const set<string>& namesOfUsedVars);
+//bool splitType
+ 
 // create constraits set
-static deque<CommConstraint> makeConstraints(deque<CommConstraint>& constraints, const set<string>& namesOfUsedVars, set<string>& notUsedVars);
+//deque<CommConstraint> makeConstraints
+ 
 // build union
-static bool buildConstraintsUnion(deque<CommConstraint>& U, deque<CommConstraint> B, const set<string>& namesOfUsedVars, pair<CommConstraint, CommConstraint>& problemConstraints);
-static bool docheckUnequalConstraints(deque<CommConstraint>& U, deque<CommConstraint>& B, deque<CommConstraint>& newU, pair<CommConstraint, CommConstraint>& problemConstraints);
-static bool check(deque<CommConstraint>& A, deque<CommConstraint>& B, pair<CommConstraint, CommConstraint>& problemConstraints);
+//bool buildConstraintsUnion
+//bool docheckUnequalConstraints
+//bool check

 /// small help functions:
-static string getParentName(const string& name);
-static bool equalDims(const CommConstraint& a, const CommConstraint& b);
-static bool equalConstraints(const CommConstraint& a, const CommConstraint& b);
-static void addElem(deque<CommConstraint>& comm, const CommConstraint& elem);
-//////
+//string getParentName
+//bool equalDims
+//bool equalConstraints
+//void addElem

 // change names of variables in 'constraints'
-static void fixNames(deque<CommConstraint>& constraints, const string& commName);
+//void fixNames

 ////// step2: transformation
-
 /// main function
 // peform transformation on every program unit in the file
-static void fixFunctions(SgFile* file, vector<SgStatement*> programUnits, map<string, deque<CommConstraint>>& newCommonDecls,
-    map<string, map<string, deque<CommConstraint>>>& commDecls, const set<string>& badCommon, map<string, set<string>>& notUsedVars);
+//void fixFunctions

 // get pairs of names (namesOldToNew) for renaming
-static bool getNamesOldToNew(deque<CommConstraint> newDecl, deque<CommConstraint> oldDecl, map<string, string>& namesOldToNew);
+//bool getNamesOldToNew

 // create new symbols for new variables in new common declaration (constraints)
-static void makeCommVarSymbs(const deque<CommConstraint>& constraints, SgFile* file, SgStatement* func, string commName,
-    map<string, SgSymbol*>& symbs, vector<SgSymbol*>& needNewDecl);
+//void makeCommVarSymbs
+
 // delete from program unit all references to names in commVarNames
-static void deleteOldVars(SgStatement* firstSt, const set<string>& commVarNames);
+//void deleteOldVars

 // calls fixExpression for each statement, replaces names in data statement
-static void renameVariables(SgStatement* firstSt, const map<string, SgSymbol*>& newVarSymbs, const map<string, string>& namesOldToNew);
+//void renameVariables
+
 // replacing variables or array elements in expression expr if their names are in namesOldToNew
-static SgExpression* fixExpression(SgExpression* expr, const map<string, SgSymbol*>& newSymbs, const map<string, string>& namesOldToNew);
+//SgExpression* fixExpression

 // make new exprList exprssion for new declaration decl with symbols from newSymbs
-static SgExpression* makeExprListForCommon(const deque<CommConstraint>& decl, const map<string, SgSymbol*>& newSymbs,
-    SgFile* file, SgStatement* firstSt);
+//SgExpression* makeExprListForCommon
+
 // replace old common declarations with new ones
-static void rewriteCommon(SgStatement* firstSt, map<string, SgExpression*>& commListExprs);
+//void rewriteCommon

 /// help functions:
-static SgExpression* makeIdxFromStr(const string& str);
+//SgExpression* makeIdxFromStr(const string& str);
+
 // make new expression of array element
-static SgExpression* newArrElemExpr(const string& newName, const map<string, SgSymbol*>& newSymbs);
-static bool variablePositionComp(const Variable* lhs, const Variable* rhs);
+//SgExpression* newArrElemExpr
+//bool variablePositionComp
 //////

-
-
 CommConstraint::CommConstraint(const Variable* var, bool u, const string& funcName, const string& fileName)
 {
    used = u;
@@ -125,7 +122,6 @@ CommConstraint::CommConstraint(const Variable* var, bool u, const string& funcNa
    }
 }

-
 CommConstraint::CommConstraint(const string& name, SgType* t, bool u) : used(u), type(t), identifier(name)
 {
    typeVariant = type->variant();
@@ -139,8 +135,7 @@ CommConstraint::CommConstraint(const string& name, SgType* t, bool u, vector<Dec
    size = getSizeOfType(type);
 }

-
-string getParentName(const string& name)
+static string getParentName(const string& name)
 {
    size_t len = name.find("%");
    size_t posB = name.find("(");
@@ -154,8 +149,7 @@ string getParentName(const string& name)
    return name.substr(0, len);
 }

-
-void getUsesFromExpr(SgExpression* expr, const set<string>& commonVarNames, set<string>& used)
+static void getUsesFromExpr(SgExpression* expr, const set<string>& commonVarNames, set<string>& used)
 {
    if (expr == NULL)
        return;
@@ -194,8 +188,7 @@ void getUsesFromExpr(SgExpression* expr, const set<string>& commonVarNames, set<
    getUsesFromExpr(expr->rhs(), commonVarNames, used);
 }

-
-set<string> getUses(SgStatement* firstSt, const set<string>& commonVarNames)
+static set<string> getUses(SgStatement* firstSt, const set<string>& commonVarNames)
 {
    set<string> used;
    SgStatement* lastSt = firstSt->lastNodeOfStmt();
@@ -212,8 +205,7 @@ set<string> getUses(SgStatement* firstSt, const set<string>& commonVarNames)
    return used;
 }

-
-bool equalDims(const CommConstraint& a, const CommConstraint& b)
+static bool equalDims(const CommConstraint& a, const CommConstraint& b)
 {
    const vector<pair<int, int>>& adim = a.arrayInfo->GetSizes();
    const vector<pair<int, int>>& bdim = b.arrayInfo->GetSizes();
@@ -224,11 +216,12 @@ bool equalDims(const CommConstraint& a, const CommConstraint& b)
        if (adim[i].second - adim[i].first != bdim[i].second - bdim[i].first)
            return false;
    }
+
+    return true;
 }

-
 // TODO: add attributes to CommConstraints, check if a and b have equal attributes
-bool equalConstraints(const CommConstraint& a, const CommConstraint& b)
+static bool equalConstraints(const CommConstraint& a, const CommConstraint& b)
 {
    if ((a.arrayInfo != NULL && b.arrayInfo == NULL) || ((a.arrayInfo == NULL && b.arrayInfo != NULL)))
        return false;
@@ -239,8 +232,7 @@ bool equalConstraints(const CommConstraint& a, const CommConstraint& b)
    return true;
 }

-
-void addElem(deque<CommConstraint>& comm, const CommConstraint& elem)
+static void addElem(deque<CommConstraint>& comm, const CommConstraint& elem)
 {
    if (elem.typeVariant == 0 && !comm.empty() && comm.back().typeVariant == 0)
        comm.back().size += elem.size;
@@ -248,9 +240,8 @@ void addElem(deque<CommConstraint>& comm, const CommConstraint& elem)
        comm.push_back(elem);
 }

-
 // TODO: check attributes: do not split arrays with pointer or target attributes if check_use == true
-bool splitType(deque<CommConstraint>& d, bool check_use, const set<string>& namesOfUsedVars = {})
+static bool splitType(deque<CommConstraint>& d, bool check_use, const set<string>& namesOfUsedVars = {})
 {
    CommConstraint var = d.front();
    string name = var.identifier;
@@ -298,8 +289,7 @@ bool splitType(deque<CommConstraint>& d, bool check_use, const set<string>& name
    }
 }

-
-deque<CommConstraint> makeConstraints(deque<CommConstraint>& constraints, const set<string>& namesOfUsedVars, set<string>& notUsedVars)
+static deque<CommConstraint> makeConstraints(deque<CommConstraint>& constraints, const set<string>& namesOfUsedVars, set<string>& notUsedVars)
 {
    deque<CommConstraint> res;
    while (!constraints.empty())
@@ -316,8 +306,7 @@ deque<CommConstraint> makeConstraints(deque<CommConstraint>& constraints, const
    return res;
 }

-
-bool check(deque<CommConstraint>& A, deque<CommConstraint>& B, pair<CommConstraint, CommConstraint>& problemConstraints)
+static bool check(deque<CommConstraint>& A, deque<CommConstraint>& B, pair<CommConstraint, CommConstraint>& problemConstraints)
 {
    while (!A.empty() && !B.empty())
    {
@@ -356,8 +345,8 @@ bool check(deque<CommConstraint>& A, deque<CommConstraint>& B, pair<CommConstrai
    return true;
 }

-
-bool docheckUnequalConstraints(deque<CommConstraint>& U, deque<CommConstraint>& B, deque<CommConstraint>& newU, pair<CommConstraint, CommConstraint>& problemConstraints)
+static bool docheckUnequalConstraints(deque<CommConstraint>& U, deque<CommConstraint>& B, deque<CommConstraint>& newU, 
+                                      pair<CommConstraint, CommConstraint>& problemConstraints)
 {
    if (U.front().typeVariant == 0)
    {
@@ -380,8 +369,8 @@ bool docheckUnequalConstraints(deque<CommConstraint>& U, deque<CommConstraint>&
    return true;
 }

-
-bool buildConstraintsUnion(deque<CommConstraint>& U, deque<CommConstraint> B, const set<string>& namesOfUsedVars, pair<CommConstraint, CommConstraint>& problemConstraints)
+static bool buildConstraintsUnion(deque<CommConstraint>& U, deque<CommConstraint> B, 
+                                  const set<string>& namesOfUsedVars, pair<CommConstraint, CommConstraint>& problemConstraints)
 {
    deque<CommConstraint> newU;
    while (!U.empty() && !B.empty())
@@ -436,8 +425,8 @@ bool buildConstraintsUnion(deque<CommConstraint>& U, deque<CommConstraint> B, co
    return true;
 }

-
-bool getNamesOldToNew(deque<CommConstraint> newDecl, deque<CommConstraint> oldDecl, map<string, string>& namesOldToNew)
+//TODO: check this: newDecl and oldDecl => do these variables need references?
+static bool getNamesOldToNew(deque<CommConstraint> newDecl, deque<CommConstraint> oldDecl, map<string, string>& namesOldToNew)
 {
    bool needChange = false;
    map<string, string> rename;
@@ -502,16 +491,18 @@ bool getNamesOldToNew(deque<CommConstraint> newDecl, deque<CommConstraint> oldDe
            newDecl.pop_front();
        }
    }
+
    if (!oldDecl.empty() || !newDecl.empty())
        needChange = true;
+
    if (needChange)
        namesOldToNew.insert(rename.begin(), rename.end());
+
    return needChange;
 }

-
-void makeCommVarSymbs(const deque<CommConstraint>& constraints, SgFile* file, SgStatement* func, string commName,
-    map<string, SgSymbol*>& symbs, vector<SgSymbol*>& needNewDecl)
+static void makeCommVarSymbs(const deque<CommConstraint>& constraints, SgFile* file, SgStatement* func, const string& commName,
+                             map<string, SgSymbol*>& symbs, vector<SgSymbol*>& needNewDecl)
 {
    for (const CommConstraint& var : constraints)
    {
@@ -524,8 +515,7 @@ void makeCommVarSymbs(const deque<CommConstraint>& constraints, SgFile* file, Sg
    }
 }

-
-void deleteOldVars(SgStatement* firstSt, const set<string>& commVarNames)
+static void deleteOldVars(SgStatement* firstSt, const set<string>& commVarNames)
 {
    SgStatement* lastSt = firstSt->lastNodeOfStmt();
    vector<SgStatement*> stmtsToDelete;
@@ -571,12 +561,12 @@ void deleteOldVars(SgStatement* firstSt, const set<string>& commVarNames)
        }
        // TODO: delete common variables form attributes statements (like DIM_STAT)
    }
+
    for (SgStatement* st : stmtsToDelete)
        st->deleteStmt();
 }

-
-SgExpression* makeIdxFromStr(const string& str)
+static SgExpression* makeIdxFromStr(const string& str)
 {
    vector<SgExpression*> items;
    int num = 0;
@@ -591,13 +581,13 @@ SgExpression* makeIdxFromStr(const string& str)
            num = 0;
        }
    }
+
    reverse(items.begin(), items.end());
    SgExpression* exprList = makeExprList(items, false);
    return exprList;
 }

-
-SgExpression* newArrElemExpr(const string& newName, const map<string, SgSymbol*>& newSymbs)
+static SgExpression* newArrElemExpr(const string& newName, const map<string, SgSymbol*>& newSymbs)
 {
    size_t pos = newName.find('(');
    SgExpression* newExpr = new SgArrayRefExp(*newSymbs.at(newName.substr(0, pos)));
@@ -605,11 +595,11 @@ SgExpression* newArrElemExpr(const string& newName, const map<string, SgSymbol*>
    return newExpr;
 }

-
-SgExpression* fixExpression(SgExpression* expr, const map<string, SgSymbol*>& newSymbs, const map<string, string>& namesOldToNew)
+static SgExpression* fixExpression(SgExpression* expr, const map<string, SgSymbol*>& newSymbs, const map<string, string>& namesOldToNew)
 {
    if (expr == NULL)
        return NULL;
+
    if (expr->variant() == VAR_REF || expr->variant() == ARRAY_REF)
    {
        string name = expr->symbol()->identifier();
@@ -645,17 +635,18 @@ SgExpression* fixExpression(SgExpression* expr, const map<string, SgSymbol*>& ne
            }
        }
    }
+
    SgExpression* lhs = fixExpression(expr->lhs(), newSymbs, namesOldToNew);
    if (lhs != NULL)
        expr->setLhs(lhs);
+
    SgExpression* rhs = fixExpression(expr->rhs(), newSymbs, namesOldToNew);
    if (rhs != NULL)
        expr->setRhs(rhs);
    return NULL;
 }

-
-void renameVariables(SgStatement* firstSt, const map<string, SgSymbol*>& newVarSymbs, const map<string, string>& namesOldToNew)
+static void renameVariables(SgStatement* firstSt, const map<string, SgSymbol*>& newVarSymbs, const map<string, string>& namesOldToNew)
 {
    SgStatement* lastSt = firstSt->lastNodeOfStmt();
    for (SgStatement* curSt = firstSt; curSt != NULL && curSt != lastSt; curSt = curSt->lexNext())
@@ -703,8 +694,7 @@ void renameVariables(SgStatement* firstSt, const map<string, SgSymbol*>& newVarS
    }
 }

-
-SgExpression* makeExprListForCommon(const deque<CommConstraint>& decl, const map<string, SgSymbol*>& newSymbs,
+static SgExpression* makeExprListForCommon(const deque<CommConstraint>& decl, const map<string, SgSymbol*>& newSymbs,
    SgFile* file, SgStatement* firstSt)
 {
    vector<SgExpression*> items;
@@ -738,8 +728,7 @@ SgExpression* makeExprListForCommon(const deque<CommConstraint>& decl, const map
    return exprList;
 }

-
-void rewriteCommon(SgStatement* firstSt, map<string, SgExpression*>& commListExprs)
+static void rewriteCommon(SgStatement* firstSt, map<string, SgExpression*>& commListExprs)
 {
    vector<SgStatement*> commonStmtsToDelete;
    for (SgStatement* st = firstSt; st != firstSt->lastDeclaration()->lexNext(); st = st->lexNext())
@@ -790,12 +779,12 @@ void rewriteCommon(SgStatement* firstSt, map<string, SgExpression*>& commListExp
                commonStmtsToDelete.push_back(st);
        }
    }
+
    for (SgStatement* st : commonStmtsToDelete)
        st->deleteStmt();
 }

-
-void fixNames(deque<CommConstraint>& constraints, const string& commName)
+static void fixNames(deque<CommConstraint>& constraints, const string& commName)
 {
    for (auto& var : constraints)
    {
@@ -810,26 +799,26 @@ void fixNames(deque<CommConstraint>& constraints, const string& commName)
    }
 }

-
-bool variablePositionComp(const Variable* lhs, const Variable* rhs)
+static bool variablePositionComp(const Variable* lhs, const Variable* rhs)
 {
    return lhs->getPosition() < rhs->getPosition();
 }

-
-void fixFunctions(SgFile* file, vector<SgStatement*> programUnits, map<string, deque<CommConstraint>>& newCommonDecls,
-    map<string, map<string, deque<CommConstraint>>>& commDecls, const set<string>& badCommon, map<string, set<string>>& notUsedVars)
+static void fixFunctions(SgFile* file, const vector<SgStatement*>& programUnits, map<string, deque<CommConstraint>>& newCommonDecls,
+                         map<string, map<string, deque<CommConstraint>>>& commDecls, const set<string>& badCommon, map<string, set<string>>& notUsedVars)
 {
    for (SgStatement* unitSt : programUnits)
    {
        string funcName = unitSt->symbol()->identifier();
        if (commDecls.find(funcName) == commDecls.end())
            continue;
+
        SgStatement* firstSt = unitSt;
        map<string, SgExpression*> commListExprs;
        map<string, SgSymbol*> newVarSymbs; // new symbols for new variables
        map<string, string> namesOldToNew; // for ranaming: old name -> new name
        vector<SgSymbol*> needNewDecl;
+
        for (auto& common : commDecls[funcName])
        {
            string commName = common.first;
@@ -840,9 +829,11 @@ void fixFunctions(SgFile* file, vector<SgStatement*> programUnits, map<string, d
            bool needChange = getNamesOldToNew(newDecl, common.second, namesOldToNew);
            if (!needChange)
                continue;
+
            makeCommVarSymbs(newDecl, file, firstSt, commName, newVarSymbs, needNewDecl);
            commListExprs[commName] = makeExprListForCommon(newDecl, newVarSymbs, file, firstSt);
        }
+
        if (!commListExprs.empty())
        {
            for (const auto& item : commListExprs)
@@ -856,10 +847,9 @@ void fixFunctions(SgFile* file, vector<SgStatement*> programUnits, map<string, d
    }
 }

-
-void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBlocks,
-        map<string, deque<CommConstraint>>& newCommonDecls, map<string, map<string, deque<CommConstraint>>>& commDecls,
-        set<string>& badCommon, map<string, set<string>>& notUsedVars, vector<SgStatement*>& programUnits)
+static void buildNewCommDecls(SgFile* file, const map<string, CommonBlock*>& allCommonBlocks,
+                              map<string, deque<CommConstraint>>& newCommonDecls, map<string, map<string, deque<CommConstraint>>>& commDecls,
+                              set<string>& badCommon, map<string, set<string>>& notUsedVars, vector<SgStatement*>& programUnits)
 {
    string fileName = file->filename();
    SgStatement* curSt = file->firstStatement();
@@ -898,7 +888,8 @@ void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBl
                    constraints.push_back(newConstr);
                }
                if (hasChar && hasNotChar)  // TDOO: make proper warning message or separate such common blocks
-                    __spf_print(1, "common block '%s' ('%s':%d) contains variables of symbolic and numeric types. It is required to divide\n", commName.c_str(), fileName.c_str(), constraints.back().uses.back().lineNum);
+                    __spf_print(1, "common block '%s' ('%s':%d) contains variables of symbolic and numeric types. It is required to divide\n", 
+                                    commName.c_str(), fileName.c_str(), constraints.back().uses.back().getLineNum());
                if (hasChar)
                {
                    badCommon.insert(commName);
@@ -915,7 +906,7 @@ void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBl
                    for (auto x : problemConstraints.first.uses)         // TODO: make proper warning message
                        for (auto y : problemConstraints.second.uses)
                            __spf_print(1, "variables '%s' and '%s' in one storage association (common block '%s') have different types (files - %s:%d and %s:%d)\n",
-                                x.varName.c_str(), y.varName.c_str(), commName.c_str(), x.fileName.c_str(), x.lineNum, y.fileName.c_str(), y.lineNum);
+                                            x.getVarName(), y.getVarName(), commName.c_str(), x.getFileName(), x.getLineNum(), y.getFileName(), y.getLineNum());
                }
            }
            curSt = curSt->lastNodeOfStmt();
@@ -927,7 +918,7 @@ void BuildNewCommDecls(SgFile* file, const map<string, CommonBlock*> allCommonBl


 // main function
-void fixCommonBlocks(const map<string, vector<FuncInfo*>> allFuncInfo, const map<string, CommonBlock*> allCommonBlocks, SgProject* project)  // TODO: separate into 2 steps?
+void fixCommonBlocks(const map<string, vector<FuncInfo*>>& allFuncInfo, const map<string, CommonBlock*>& allCommonBlocks, SgProject* project)  // TODO: separate into 2 steps?
 {
    int filesNum = project->numberOfFiles();
    map<string, map<string, map<string, deque<CommConstraint>>>> commDecls; // file_name -> function_name -> common block name -> old declaration of common block
@@ -941,10 +932,12 @@ void fixCommonBlocks(const map<string, vector<FuncInfo*>> allFuncInfo, const map
        SgFile* file = &project->file(i);
        string fileName = file->filename();
        file->switchToFile(fileName);
-        BuildNewCommDecls(file, allCommonBlocks, newCommonDecls, commDecls[fileName], badCommon, notUsedVars, programUnitsInFile[fileName]);
+        buildNewCommDecls(file, allCommonBlocks, newCommonDecls, commDecls[fileName], badCommon, notUsedVars, programUnitsInFile[fileName]);
    }
+
    for (auto& elem : newCommonDecls)
        fixNames(elem.second, elem.first);
+
    for (int i = 0; i < filesNum; i++)  // second step
    {
        SgFile* file = &project->file(i);
--- a/src/Transformations/GlobalVariables/fix_common_blocks.h
+++ b/src/Transformations/GlobalVariables/fix_common_blocks.h
@@ -16,12 +16,18 @@

 struct DeclInfo // for error messages
 {
+private:
    std::string varName;
    std::string fileName;
    int lineNum;

+public:
    DeclInfo() : varName(""), fileName(""), lineNum(0) {};
    DeclInfo(const std::string& vn, const std::string& fn, int ln) : varName(vn), fileName(fn), lineNum(ln) {};
+
+    const char* getVarName() const { return varName.c_str(); }
+    const char* getFileName() const { return fileName.c_str(); }
+    int getLineNum() const { return lineNum; }
 };

 struct CommConstraint  // TODO: add variable attributes
@@ -42,4 +48,4 @@ struct CommConstraint  // TODO: add variable attributes
 };


-void fixCommonBlocks(const std::map<std::string, std::vector<FuncInfo*>> allFuncInfo, const std::map<std::string, CommonBlock*> allCommonBlocks, SgProject* project);
+void fixCommonBlocks(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo, const std::map<std::string, CommonBlock*>& allCommonBlocks, SgProject* project);
--- a/src/Transformations/LoopSplitting/loops_splitter.cpp
+++ b/src/Transformations/LoopSplitting/loops_splitter.cpp
@@ -19,6 +19,7 @@ using std::pair;
 using std::make_pair;
 using std::wstring;
 using std::stack;
+using SAPFOR::CFG_Settings;

 #define PRINT_SPLITTED_FRAGMENTS 0

@@ -315,7 +316,7 @@ static map<SgStatement*, pair<set<SgStatement*>, set<SgStatement*>>>
                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);

            map<SAPFOR::Argument*, set<int>> outForCurr;
-            buildGenKillForCFG(itCFG->second, funcByName, outForFunc, gen, kill, &genForIR, &killForIR, notInitedGlobals, SAPFOR::CFG_Settings(0));
+            buildGenKillForCFG(itCFG->second, funcByName, outForFunc, gen, kill, &genForIR, &killForIR, notInitedGlobals, SAPFOR::CFG_Settings());
            
            if (outForFunc.count(byFunc))
                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
@@ -1051,7 +1052,8 @@ int splitLoops(SgFile *file, vector<LoopGraph*> &loopGraphs, vector<Messages> &m
                checkNull(listExp, convertFileName(__FILE__).c_str(), __LINE__);
                int deep = listExp->length();
                
-                currIR = buildCFGforCurrentFunc(loop->loop, SAPFOR::CFG_Settings(true, true), commonBlocks, allFuncInfo);
+                const auto settings = CFG_Settings({ CFG_Settings::CFG_atLeastOneIterInLoop, CFG_Settings::CFG_withRD, CFG_Settings::CFG_withCallFrom, CFG_Settings::CFG_withDominators });
+                currIR = buildCFGforCurrentFunc(loop->loop, settings, commonBlocks, allFuncInfo);
                totalErr = splitLoop(loop, messages, deep, depInfoForLoopGraph);

                if (totalErr > 0)
--- a/src/Transformations/MoveOperators/move_operators.cpp
+++ b/src/Transformations/MoveOperators/move_operators.cpp
@@ -0,0 +1,826 @@
+#include <map>
+#include <unordered_set>
+#include <vector>
+#include <queue>
+#include <iostream>
+#include <algorithm>
+
+#include "../../Utils/errors.h"
+#include "../../Utils/SgUtils.h"
+#include "../../GraphCall/graph_calls.h"
+#include "../../GraphCall/graph_calls_func.h"
+#include "../../CFGraph/CFGraph.h"
+#include "../../CFGraph/IR.h"
+#include "../../GraphLoop/graph_loops.h"
+#include "move_operators.h"
+
+using namespace std;
+
+static vector<SAPFOR::IR_Block*> findInstructionsFromOperator(SgStatement* st, const vector<SAPFOR::BasicBlock*>& Blocks) {
+    vector<SAPFOR::IR_Block*> result;
+    string filename = st->fileName();
+    
+    for (auto& block: Blocks) {
+        vector<SAPFOR::IR_Block*> instructionsInBlock = block->getInstructions();
+
+        for (auto& instruction: instructionsInBlock) {
+            SgStatement* curOperator = instruction->getInstruction()->getOperator();
+            if (curOperator->lineNumber() == st->lineNumber())
+                result.push_back(instruction);
+        }
+    }
+    return result;
+}
+
+const unordered_set<int> loop_tags = { FOR_NODE };
+const unordered_set<int> control_tags = { IF_NODE, ELSEIF_NODE, DO_WHILE_NODE, WHILE_NODE, LOGIF_NODE };
+const unordered_set<int> control_end_tags = { CONTROL_END };
+
+struct OperatorInfo {
+    SgStatement* stmt;
+    set<string> usedVars;
+    set<string> definedVars;
+    int lineNumber;
+    bool isMovable;
+    
+    OperatorInfo(SgStatement* s) : stmt(s), lineNumber(s->lineNumber()), isMovable(true) { }
+};
+
+static bool isStatementEmbedded(SgStatement* stmt, SgStatement* parent) {
+    if (!stmt || !parent || stmt == parent)
+        return false;
+    
+    if (parent->variant() == LOGIF_NODE) {
+        if (stmt->lineNumber() == parent->lineNumber())
+            return true;
+        
+        SgStatement* current = parent;
+        SgStatement* lastNode = parent->lastNodeOfStmt();
+
+        while (current && current != lastNode) {
+            if (current == stmt)
+                return true;
+
+            if (current->isIncludedInStmt(*stmt))
+                return true;
+
+            current = current->lexNext();
+        }
+    }
+    
+    if (parent->isIncludedInStmt(*stmt))
+        return true;
+    
+    return false;
+}
+
+static bool isLoopBoundary(SgStatement* stmt) {
+    if (!stmt)
+        return false;
+    
+    if (stmt->variant() == FOR_NODE || stmt->variant() == CONTROL_END)
+        return true;
+    
+    return false;
+}
+
+static bool isPartOfNestedLoop(SgStatement* stmt, SgForStmt* loop) {
+    if (!stmt || !loop)
+        return false;
+    
+    SgStatement* loopStart = loop->lexNext();
+    SgStatement* loopEnd = loop->lastNodeOfStmt();
+    if (!loopStart || !loopEnd)
+        return false;
+    
+    if (stmt->lineNumber() < loopStart->lineNumber() || stmt->lineNumber() > loopEnd->lineNumber())
+        return false;
+    
+    SgStatement* current = loopStart;
+    
+    while (current && current != loopEnd) {
+        
+        if (current->variant() == FOR_NODE && current != loop) {
+            SgForStmt* nestedLoop = (SgForStmt*)current;
+            SgStatement* nestedStart = nestedLoop->lexNext();
+            SgStatement* nestedEnd = nestedLoop->lastNodeOfStmt();
+            
+            if (nestedStart && nestedEnd && 
+                stmt->lineNumber() >= nestedStart->lineNumber() && 
+                stmt->lineNumber() <= nestedEnd->lineNumber()) {
+                return true;
+            }
+        }
+        
+        current = current->lexNext();
+    }
+    
+    return false;
+}
+
+static bool canSafelyExtract(SgStatement* stmt, SgForStmt* loop) {
+    if (!stmt || !loop)
+        return false;
+    
+    if (isLoopBoundary(stmt))
+        return false;
+    
+    if (control_tags.find(stmt->variant()) != control_tags.end())
+        return false;
+    
+    if (isPartOfNestedLoop(stmt, loop))
+        return false;
+    
+    SgStatement* loopStart = loop->lexNext();
+    SgStatement* loopEnd = loop->lastNodeOfStmt();
+    if (!loopStart || !loopEnd) 
+        return false;
+    
+    SgStatement* current = loopStart;
+    
+    while (current && current != loopEnd) {
+        if (current->variant() == LOGIF_NODE && current->lineNumber() == stmt->lineNumber())
+            return false;
+
+        if (control_tags.find(current->variant()) != control_tags.end())
+            if (isStatementEmbedded(stmt, current))
+                return false;
+
+        if (current == stmt) 
+            break;
+        current = current->lexNext();
+    }
+    
+    return true;
+}
+
+static vector<OperatorInfo> analyzeOperatorsInLoop(SgForStmt* loop, const vector<SAPFOR::BasicBlock*>& blocks, 
+                                                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+    vector<OperatorInfo> operators;
+    SgStatement* loopStart = loop->lexNext();
+    SgStatement* loopEnd = loop->lastNodeOfStmt();
+    
+    if (!loopStart || !loopEnd)
+        return operators;
+    
+    SgStatement* current = loopStart;
+    unordered_set<SgStatement*> visited;
+    
+    while (current && current != loopEnd) {
+        
+        if (visited.find(current) != visited.end())
+            break;
+
+        visited.insert(current);
+        
+        if (isLoopBoundary(current)) {
+            current = current->lexNext();
+            continue;
+        }
+        
+        if (current->variant() == FOR_NODE && current != loop) {
+            SgStatement* nestedEnd = current->lastNodeOfStmt();
+            if (nestedEnd)
+                current = nestedEnd->lexNext();
+            else
+                current = current->lexNext();
+            continue;
+        }
+        
+        if (isSgExecutableStatement(current)) {
+            if (control_tags.find(current->variant()) != control_tags.end()) {
+                current = current->lexNext();
+                continue;
+            }
+
+            if (current->variant() != ASSIGN_STAT) {
+                current = current->lexNext();
+                continue;
+            }
+            
+            OperatorInfo opInfo(current);
+            
+            vector<SAPFOR::IR_Block*> irBlocks = findInstructionsFromOperator(current, blocks);
+            for (auto irBlock : irBlocks) {
+                if (!irBlock || !irBlock->getInstruction()) 
+                    continue;
+                
+                const SAPFOR::Instruction* instr = irBlock->getInstruction();
+                if (instr->getArg1()) {
+                    string varName = getNameByArg(instr->getArg1());
+                    if (!varName.empty())
+                        opInfo.usedVars.insert(varName);
+                }
+
+                if (instr->getArg2()) {
+                    string varName = getNameByArg(instr->getArg2());
+                    if (!varName.empty())
+                        opInfo.usedVars.insert(varName);
+                }
+
+                if (instr->getResult()) {
+                    string varName = getNameByArg(instr->getResult());
+                    if (!varName.empty())
+                        opInfo.definedVars.insert(varName);
+                }
+            }
+            
+            operators.push_back(opInfo);
+        }
+        current = current->lexNext();
+    }
+    
+    return operators;
+}
+
+static map<string, vector<SgStatement*>> findVariableDefinitions(SgForStmt* loop, vector<OperatorInfo>& operators) {
+    map<string, vector<SgStatement*>> varDefinitions;
+    for (auto& op : operators)
+        for (const string& var : op.definedVars)
+            varDefinitions[var].push_back(op.stmt);
+
+    return varDefinitions;
+}
+
+static int calculateDistance(SgStatement* from, SgStatement* to) {
+    if (!from || !to) 
+        return INT_MAX;
+
+    return abs(to->lineNumber() - from->lineNumber());
+}
+
+static SgStatement* findBestPosition(SgStatement* operatorStmt, const vector<OperatorInfo>& operators, 
+                                     const map<string, vector<SgStatement*>>& varDefinitions, SgForStmt* loop) {
+    const OperatorInfo* opInfo = nullptr;
+    for (auto& op : operators) {
+        if (op.stmt == operatorStmt) {
+            opInfo = &op;
+            break;
+        }
+    }
+
+    if (!opInfo || !opInfo->isMovable)
+        return nullptr;
+    
+    SgStatement* bestPos = nullptr;
+    int bestLine = -1;
+    
+    for (const string& usedVar : opInfo->usedVars) {
+        if (varDefinitions.find(usedVar) != varDefinitions.end()) {
+            for (SgStatement* defStmt : varDefinitions.at(usedVar)) {
+                if (defStmt->lineNumber() < operatorStmt->lineNumber()) {
+                    if (defStmt->controlParent() == operatorStmt->controlParent()) {
+                        if (defStmt->lineNumber() > bestLine) {
+                            bestLine = defStmt->lineNumber();
+                            bestPos = defStmt;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    if (!bestPos) {
+        bool allLoopCarried = true;
+        bool hasAnyDefinition = false;
+        
+        for (const string& usedVar : opInfo->usedVars) {
+            if (varDefinitions.find(usedVar) != varDefinitions.end()) {
+                for (SgStatement* defStmt : varDefinitions.at(usedVar)) {
+                    if (defStmt == operatorStmt)
+                        continue;
+                    
+                    hasAnyDefinition = true;
+                    if (defStmt->lineNumber() < operatorStmt->lineNumber() &&
+                        defStmt->controlParent() == operatorStmt->controlParent()) {
+                        allLoopCarried = false;
+                        break;
+                    }
+                }
+            }
+
+            if (!allLoopCarried) 
+                break;
+        }
+        
+        if (allLoopCarried || (!hasAnyDefinition && !opInfo->usedVars.empty())) {
+            SgStatement* loopStart = loop->lexNext();
+            return loopStart;
+        }
+    }
+    
+    return bestPos;
+}
+
+static bool canMoveTo(SgStatement* from, SgStatement* to, SgForStmt* loop) {
+    if (!from || !to || from == to)
+        return false;
+    
+    SgStatement* loopStart = loop->lexNext();
+    SgStatement* loopEnd = loop->lastNodeOfStmt();
+    
+    if (!loopStart || !loopEnd) 
+        return false;
+    
+    if (to == loopStart) {
+        SgStatement* fromControlParent = from->controlParent();
+        if (!fromControlParent) fromControlParent = loop;
+        return fromControlParent == loop || fromControlParent == loopStart->controlParent();
+    }
+    
+    if (from->lineNumber() < loopStart->lineNumber() || from->lineNumber() > loopEnd->lineNumber())
+        return false;
+
+    if (to->lineNumber() < loopStart->lineNumber() || to->lineNumber() > loopEnd->lineNumber())
+        return false;
+    
+    if (to->lineNumber() >= from->lineNumber())
+        return false;
+    
+    if (from->controlParent() != to->controlParent())
+        return false;
+    
+    SgStatement* current = to->lexNext();
+    while (current && current != from && current != loopEnd) {
+        if (control_tags.find(current->variant()) != control_tags.end()) {
+            SgStatement* controlEnd = current->lastNodeOfStmt();
+            if (controlEnd && from->lineNumber() <= controlEnd->lineNumber()) {
+                if (from->controlParent() == current && to->controlParent() != current) {
+                    return false;
+                }
+            }
+        }
+        current = current->lexNext();
+    }
+    
+    return true;
+}
+
+static vector<SgStatement*> optimizeOperatorOrder(SgForStmt* loop, 
+                                                  const vector<OperatorInfo>& operators, 
+                                                  const map<string, vector<SgStatement*>>& varDefinitions) {
+    vector<SgStatement*> newOrder;
+    for (auto& op : operators)
+        newOrder.push_back(op.stmt);
+    
+    map<SgStatement*, const OperatorInfo*> stmtToOpInfo;
+    for (auto& op : operators) 
+        stmtToOpInfo[op.stmt] = &op;
+    
+    bool changed = true;
+    
+    while (changed) {
+        changed = false;
+        
+        for (int i = operators.size() - 1; i >= 0; i--) {
+            if (!operators[i].isMovable) 
+                continue;
+            
+            SgStatement* stmt = operators[i].stmt;
+            const OperatorInfo* opInfo = stmtToOpInfo[stmt];
+
+            if (!opInfo)
+                continue;
+            
+            size_t currentPos = 0;
+            for (size_t j = 0; j < newOrder.size(); j++) {
+                if (newOrder[j] == stmt) {
+                    currentPos = j;
+                    break;
+                }
+            }
+            
+            SgStatement* bestPos = findBestPosition(stmt, operators, varDefinitions, loop);
+            
+            if (!bestPos) {
+                bool hasDependents = false;
+                for (size_t j = currentPos + 1; j < newOrder.size(); j++) {
+                    SgStatement* candidate = newOrder[j];
+                    const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                    if (candidateOpInfo) {
+                        for (const string& definedVar : opInfo->definedVars) {
+                            if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
+                                hasDependents = true;
+                                break;
+                            }
+                        }
+
+                        if (hasDependents) 
+                            break;
+                    }
+                }
+                
+                continue;
+            }
+            
+            size_t targetPos = 0;
+            bool foundTarget = false;
+            
+            if (bestPos == loop->lexNext()) {
+                targetPos = 0;
+                
+                for (size_t j = 0; j < currentPos && j < newOrder.size(); j++) {
+                    SgStatement* candidate = newOrder[j];
+                    const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                    if (candidateOpInfo) {
+                        bool usesDefinedVar = false;
+                        for (const string& definedVar : opInfo->definedVars) {
+                            if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
+                                usesDefinedVar = true;
+                                break;
+                            }
+                        }
+
+                        if (usesDefinedVar) {
+                            targetPos = j;
+                            break;
+                        }
+                    }
+                }
+                
+                foundTarget = true;
+                
+                if (currentPos != targetPos && canMoveTo(stmt, bestPos, loop)) {
+                    newOrder.erase(newOrder.begin() + currentPos);
+                    newOrder.insert(newOrder.begin() + targetPos, stmt);
+                    changed = true;
+                }
+            } else {
+                size_t bestPosIdx = 0;
+                bool foundBestPos = false;
+                for (size_t j = 0; j < newOrder.size(); j++) {
+                    if (newOrder[j] == bestPos) {
+                        bestPosIdx = j;
+                        foundBestPos = true;
+                        break;
+                    }
+                }
+                
+                if (foundBestPos) {
+                    targetPos = bestPosIdx + 1;
+                    
+                    for (size_t j = bestPosIdx + 1; j < currentPos && j < newOrder.size(); j++) {
+                        SgStatement* candidate = newOrder[j];
+                        const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                        if (candidateOpInfo) {
+                            bool definesUsedVar = false;
+                            for (const string& usedVar : opInfo->usedVars) {
+                                if (candidateOpInfo->definedVars.find(usedVar) != candidateOpInfo->definedVars.end()) {
+                                    definesUsedVar = true;
+                                    break;
+                                }
+                            }
+                            if (definesUsedVar)
+                                targetPos = j + 1;
+                        }
+                    }
+                    
+                    bool wouldBreakDependency = false;
+                    for (size_t j = targetPos; j < currentPos && j < newOrder.size(); j++) {
+                        SgStatement* candidate = newOrder[j];
+                        const OperatorInfo* candidateOpInfo = stmtToOpInfo[candidate];
+                        if (candidateOpInfo) {
+                            for (const string& definedVar : opInfo->definedVars) {
+                                if (candidateOpInfo->usedVars.find(definedVar) != candidateOpInfo->usedVars.end()) {
+                                    wouldBreakDependency = true;
+                                    break;
+                                }
+                            }
+
+                            if (wouldBreakDependency) 
+                                break;
+                        }
+                    }
+                    
+                    if (!wouldBreakDependency && currentPos > targetPos && canMoveTo(stmt, bestPos, loop)) {
+                        newOrder.erase(newOrder.begin() + currentPos);
+                        newOrder.insert(newOrder.begin() + targetPos, stmt);
+                        changed = true;
+                    }
+                }
+            }
+        }
+    }
+    
+    bool dependencyViolation = true;
+    set<pair<SgStatement*, SgStatement*>> triedPairs;
+    
+    while (dependencyViolation) {
+        dependencyViolation = false;
+        triedPairs.clear();
+        
+        for (size_t i = 0; i < newOrder.size(); i++) {
+            SgStatement* stmt = newOrder[i];
+            const OperatorInfo* opInfo = stmtToOpInfo[stmt];
+            if (!opInfo) 
+                continue;
+            
+            for (size_t j = 0; j < i; j++) {
+                SgStatement* prevStmt = newOrder[j];
+                const OperatorInfo* prevOpInfo = stmtToOpInfo[prevStmt];
+                if (!prevOpInfo)
+                    continue;
+                
+                pair<SgStatement*, SgStatement*> key = make_pair(stmt, prevStmt);
+                if (triedPairs.find(key) != triedPairs.end())
+                    continue;
+                
+                bool violation = false;
+                for (const string& definedVar : opInfo->definedVars) {
+                    if (prevOpInfo->usedVars.find(definedVar) != prevOpInfo->usedVars.end()) {
+                        violation = true;
+                        break;
+                    }
+                }
+                
+                if (violation) {
+                    triedPairs.insert(key);
+                    
+                    bool wouldCreateViolation = false;
+                    for (size_t k = j; k < i; k++) {
+                        SgStatement* betweenStmt = newOrder[k];
+                        const OperatorInfo* betweenOpInfo = stmtToOpInfo[betweenStmt];
+
+                        if (!betweenOpInfo)
+                            continue;
+                        
+                        for (const string& usedVar : opInfo->usedVars) {
+                            if (betweenOpInfo->definedVars.find(usedVar) != betweenOpInfo->definedVars.end()) {
+                                wouldCreateViolation = true;
+                                break;
+                            }
+                        }
+
+                        if (wouldCreateViolation)
+                            break;
+                    }
+                    
+                    if (!wouldCreateViolation) {
+                        newOrder.erase(newOrder.begin() + i);
+                        newOrder.insert(newOrder.begin() + j, stmt);
+                        dependencyViolation = true;
+                        break;
+                    }
+                }
+            }
+
+            if (dependencyViolation)
+                break;
+        }
+    }
+    
+    return newOrder;
+}
+
+static bool applyOperatorReordering(SgForStmt* loop, const vector<SgStatement*>& newOrder) {
+    if (!loop || newOrder.empty()) 
+        return false;
+    
+    SgStatement* loopStart = loop->lexNext();
+    SgStatement* loopEnd = loop->lastNodeOfStmt();
+    
+    if (!loopStart || !loopEnd) 
+        return false;
+    
+    vector<SgStatement*> originalOrder;
+    SgStatement* current = loopStart;
+    while (current && current != loopEnd) {
+        if (isSgExecutableStatement(current) && current->variant() == ASSIGN_STAT)
+            originalOrder.push_back(current);
+
+        current = current->lexNext();
+    }
+    
+    bool orderChanged = false;
+    if (originalOrder.size() == newOrder.size()) {
+        for (size_t i = 0; i < originalOrder.size(); i++) {
+            if (originalOrder[i] != newOrder[i]) {
+                orderChanged = true;
+                break;
+            }
+        }
+    } 
+    else
+        orderChanged = true;
+    
+    if (!orderChanged)
+        return false;
+
+    vector<SgStatement*> extractedStatements;
+    vector<char*> savedComments;
+    unordered_set<SgStatement*> extractedSet;
+    map<SgStatement*, int> originalLineNumbers;
+    map<SgStatement*, SgStatement*> stmtToExtracted;
+    
+    for (SgStatement* stmt : newOrder) {
+        if (stmt && stmt != loop && stmt != loopEnd && extractedSet.find(stmt) == extractedSet.end()) {
+            if (control_tags.find(stmt->variant()) != control_tags.end())
+                continue;
+            
+            if (!canSafelyExtract(stmt, loop))
+                continue;
+            
+            bool isMoving = false;
+            for (size_t i = 0; i < originalOrder.size(); i++) {
+                if (originalOrder[i] == stmt) {
+                    for (size_t j = 0; j < newOrder.size(); j++) {
+                        if (newOrder[j] == stmt && i != j) {
+                            isMoving = true;
+                            break;
+                        }
+                    }
+                    break;
+                }
+            }
+            
+            if (!isMoving)
+                continue;
+            
+            originalLineNumbers[stmt] = stmt->lineNumber();
+            savedComments.push_back(stmt->comments() ? strdup(stmt->comments()) : nullptr);
+            SgStatement* extracted = stmt->extractStmt();
+            if (extracted) {
+                extractedStatements.push_back(extracted);
+                extractedSet.insert(stmt);
+                stmtToExtracted[stmt] = extracted;
+            }
+        }
+    }
+    
+    map<SgStatement*, SgStatement*> insertedStatements;
+    
+    for (size_t idx = 0; idx < newOrder.size(); idx++) {
+        SgStatement* stmt = newOrder[idx];
+        
+        if (extractedSet.find(stmt) != extractedSet.end()) {
+            SgStatement* stmtToInsert = stmtToExtracted[stmt];
+
+            if (!stmtToInsert) 
+                continue;
+            
+            SgStatement* insertAfter = loop;
+            
+            for (int i = idx - 1; i >= 0; i--) {
+                SgStatement* prevStmt = newOrder[i];
+                
+                if (extractedSet.find(prevStmt) != extractedSet.end()) {
+                    if (insertedStatements.find(prevStmt) != insertedStatements.end()) {
+                        insertAfter = insertedStatements[prevStmt];
+                        break;
+                    }
+                } else {
+                    SgStatement* search = loop->lexNext();
+                    while (search && search != loopEnd) {
+                        bool skip = false;
+                        for (size_t j = idx; j < newOrder.size(); j++) {
+                            if (extractedSet.find(newOrder[j]) != extractedSet.end() && 
+                                search == newOrder[j]) {
+                                skip = true;
+                                break;
+                            }
+                        }
+                        if (skip) {
+                            search = search->lexNext();
+                            continue;
+                        }
+                        
+                        if (search == prevStmt) {
+                            insertAfter = search;
+                            break;
+                        }
+                        search = search->lexNext();
+                    }
+                    if (insertAfter != loop) break;
+                }
+            }
+            
+            size_t commentIdx = 0;
+            for (size_t i = 0; i < extractedStatements.size(); i++) {
+                if (extractedStatements[i] == stmtToInsert) {
+                    commentIdx = i;
+                    break;
+                }
+            }
+            
+            if (commentIdx < savedComments.size() && savedComments[commentIdx])
+                stmtToInsert->setComments(savedComments[commentIdx]);
+            
+            if (originalLineNumbers.find(stmt) != originalLineNumbers.end())
+                stmtToInsert->setlineNumber(originalLineNumbers[stmt]);
+            
+            SgStatement* controlParent = stmt->controlParent();
+            if (!controlParent)
+                controlParent = loop;
+            
+            insertAfter->insertStmtAfter(*stmtToInsert, *controlParent);
+            insertedStatements[stmt] = stmtToInsert;
+        }
+    }
+    
+    for (char* comment : savedComments) {
+        if (comment)
+            free(comment);
+    }
+    
+    return true;
+}
+
+vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+    vector<SAPFOR::BasicBlock*> result;
+    Statement* forSt = (Statement*)st;
+
+    for (auto& func: FullIR) {
+        if (func.first->funcPointer->getCurrProcessFile() == forSt->getCurrProcessFile()
+            && func.first->funcPointer->lineNumber() == forSt->lineNumber())
+        {
+            result = func.second;
+        }
+    }
+    return result;
+}
+
+map<SgForStmt*, vector<SAPFOR::BasicBlock*>> findAndAnalyzeLoops(SgStatement *st, const vector<SAPFOR::BasicBlock*>& blocks) {
+    map<SgForStmt*, vector<SAPFOR::BasicBlock*>> result;
+    SgStatement *lastNode = st->lastNodeOfStmt();
+    
+    while (st && st != lastNode) {
+        if (loop_tags.find(st -> variant()) != loop_tags.end()) {
+            SgForStmt *forSt = (SgForStmt*)st;
+            SgStatement *loopBody = forSt -> body();
+            SgStatement *lastLoopNode = st->lastNodeOfStmt();
+            unordered_set<int> blocks_nums;
+            
+            while (loopBody && loopBody != lastLoopNode) {
+                vector<SAPFOR::IR_Block*> irBlocks = findInstructionsFromOperator(loopBody, blocks);
+                if (!irBlocks.empty()) {
+                    SAPFOR::IR_Block* IR = irBlocks.front();
+                    if (IR && IR->getBasicBlock()) {
+                        if (blocks_nums.find(IR -> getBasicBlock() -> getNumber()) == blocks_nums.end()) {
+                            result[forSt].push_back(IR -> getBasicBlock());
+                            blocks_nums.insert(IR -> getBasicBlock() -> getNumber());
+                        }
+                    }
+                }
+                loopBody = loopBody -> lexNext();
+            }
+            sort(result[forSt].begin(), result[forSt].end());
+        }
+        st = st -> lexNext();
+    }
+    return result;
+}
+
+static void processLoopRecursively(SgForStmt* loop, const vector<SAPFOR::BasicBlock*>& blocks, 
+                                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR) {
+    if (!loop) 
+        return;
+    
+    SgStatement* loopStart = loop->lexNext();
+    SgStatement* loopEnd = loop->lastNodeOfStmt();
+    if (loopStart && loopEnd) {
+        SgStatement* current = loopStart;
+        while (current && current != loopEnd) {
+            if (current->variant() == FOR_NODE && current != loop) {
+                SgForStmt* nestedLoop = (SgForStmt*)current;
+                processLoopRecursively(nestedLoop, blocks, FullIR);
+                SgStatement* nestedEnd = nestedLoop->lastNodeOfStmt();
+
+                if (nestedEnd)
+                    current = nestedEnd->lexNext();
+                else
+                    current = current->lexNext();
+            } 
+            else
+                current = current->lexNext();
+        }
+    }
+    
+    vector<OperatorInfo> operators = analyzeOperatorsInLoop(loop, blocks, FullIR);
+    if (!operators.empty()) {
+        map<string, vector<SgStatement*>> varDefinitions = findVariableDefinitions(loop, operators);
+        vector<SgStatement*> newOrder = optimizeOperatorOrder(loop, operators, varDefinitions);
+        applyOperatorReordering(loop, newOrder);
+    }
+}
+
+void moveOperators(SgFile *file, map<string, vector<LoopGraph*>>& loopGraph, 
+                   const map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, 
+                   int& countOfTransform) {
+    countOfTransform += 1;
+    
+    //cout << "MOVE_OPERATORS Pass Started" << endl;
+
+    const int funcNum = file -> numberOfFunctions();
+    
+    for (int i = 0; i < funcNum; ++i) {
+        SgStatement *st = file -> functions(i);
+        
+        vector<SAPFOR::BasicBlock*> blocks = findFuncBlocksByFuncStatement(st, FullIR);        
+        map<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopsMapping = findAndAnalyzeLoops(st, blocks);
+        
+        for (auto& loopForAnalyze: loopsMapping)
+            processLoopRecursively(loopForAnalyze.first, loopForAnalyze.second, FullIR);
+    }
+    
+    //cout << "MOVE_OPERATORS Pass Completed" << endl;
+}
--- a/src/Transformations/MoveOperators/move_operators.h
+++ b/src/Transformations/MoveOperators/move_operators.h
@@ -0,0 +1,6 @@
+#pragma once
+
+#include "../../GraphLoop/graph_loops.h"
+#include "../../CFGraph/CFGraph.h"
+
+void moveOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);
--- a/src/Transformations/PrivateArrayRemoving/private_removing.cpp
+++ b/src/Transformations/PrivateArrayRemoving/private_removing.cpp
@@ -13,6 +13,7 @@ using std::set;
 using std::string;
 using std::vector;
 using std::wstring;
+using SAPFOR::CFG_Settings;

 using CFG_Type = map<FuncInfo*, vector<SAPFOR::BasicBlock*>>;
 using UsersDirectives = map<pair<string, int>, set<SgStatement*>>;
@@ -2207,8 +2208,8 @@ static void removePrivateAnalyze(Context *ctx)
        makeDeclaration(ctx->loopStmt, vector<SgSymbol*> {receiverVar}, nullptr)
    ));

-    CFG_Type CFG_ForFunc = buildCFGforCurrentFunc(ctx->loopStmt,
-                                                  SAPFOR::CFG_Settings(true, true),
+    const auto settings = CFG_Settings({ CFG_Settings::CFG_atLeastOneIterInLoop, CFG_Settings::CFG_withRD, CFG_Settings::CFG_withCallFrom, CFG_Settings::CFG_withDominators });
+    CFG_Type CFG_ForFunc = buildCFGforCurrentFunc(ctx->loopStmt, settings,
                                                  ctx->commonBlocks, ctx->allFuncInfo);
    if (CFG_ForFunc.empty())
        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
--- a/src/Utils/PassManager.h
+++ b/src/Utils/PassManager.h
@@ -206,7 +206,9 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>

    Pass(DEF_USE_STAGE1) <= Pass(DEF_USE_STAGE2);

-    list({ VERIFY_DVM_DIRS, PRIVATE_CALL_GRAPH_STAGE1, PRIVATE_CALL_GRAPH_STAGE2, MACRO_EXPANSION, CONVERT_ASSIGN_TO_LOOP, DEF_USE_STAGE1, DEF_USE_STAGE2, FILL_PARALLEL_REG_IR, VERIFY_COMMON, FILL_COMMON_BLOCKS, CALL_GRAPH_IR }) <= list({ SUBST_EXPR, SUBST_EXPR_RD, BUILD_IR });
+    list({ VERIFY_DVM_DIRS, VERIFY_COMMON, FILL_COMMON_BLOCKS, PRIVATE_CALL_GRAPH_STAGE1, PRIVATE_CALL_GRAPH_STAGE2, MACRO_EXPANSION, CONVERT_ASSIGN_TO_LOOP, DEF_USE_STAGE1, DEF_USE_STAGE2, FILL_PARALLEL_REG_IR, CALL_GRAPH_IR }) <= list({ SUBST_EXPR, SUBST_EXPR_RD, BUILD_IR });
+
+    Pass(VERIFY_COMMON) <= Pass(FILL_COMMON_BLOCKS);

    Pass(BUILD_IR) <= Pass(SUBST_EXPR) <= Pass(SUBST_EXPR_AND_UNPARSE);

@@ -217,7 +219,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>

    Pass(RESTORE_LOOP_FROM_ASSIGN) <= list({ SUBST_EXPR_AND_UNPARSE, SUBST_EXPR_RD_AND_UNPARSE });

-    Pass(GET_ALL_ARRAY_DECL) <= list({ CALL_GRAPH_IR, INSERT_NO_DISTR_FLAGS_FROM_GUI });
+    Pass(FILL_COMMON_BLOCKS) <= Pass(GET_ALL_ARRAY_DECL) <= list({ CALL_GRAPH_IR, INSERT_NO_DISTR_FLAGS_FROM_GUI });

    Pass(LOOP_GRAPH) <= Pass(PRIVATE_CALL_GRAPH_STAGE3) <= list(FIND_FUNC_TO_INCLUDE, PRIVATE_ANALYSIS_IR) <= list({ LOOP_ANALYZER_DATA_DIST_S0, LOOP_ANALYZER_DATA_DIST_S1, ONLY_ARRAY_GRAPH, LOOP_ANALYZER_ALIGNS });

@@ -227,7 +229,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>

    list({ VERIFY_OPERATORS, VERIFY_ENDDO, VERIFY_INCLUDES, PREPROC_SPF, PREPROC_ALLOCATES, GET_ALL_ARRAY_DECL, GCOV_PARSER }) <= list({ CALL_GRAPH, MACRO_EXPANSION, DEF_USE_STAGE1 });

-    list({ VERIFY_OPERATORS, VERIFY_ENDDO, VERIFY_INCLUDES, PREPROC_ALLOCATES, FILL_PARALLEL_REG_IR }) <= list({ GET_ALL_ARRAY_DECL, FILL_COMMON_BLOCKS, PARSE_OMP_DIRS }) <= Pass(PREPROC_SPF);
+    list({ VERIFY_OPERATORS, VERIFY_ENDDO, VERIFY_INCLUDES, PREPROC_ALLOCATES, FILL_PARALLEL_REG_IR }) <= list({ FILL_COMMON_BLOCKS, GET_ALL_ARRAY_DECL, PARSE_OMP_DIRS }) <= Pass(PREPROC_SPF);

    Pass(CHECK_PAR_REG_DIR) <= Pass(FILL_PARALLEL_REG_IR);

@@ -319,6 +321,8 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>
    list({ CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH, LOOP_ANALYZER_DATA_DIST_S2 }) <= Pass(FIND_PRIVATE_ARRAYS_ANALYSIS);
    list({ FIND_PRIVATE_ARRAYS_ANALYSIS, CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(FIND_PRIVATE_ARRAYS);

+    list({ BUILD_IR, CALL_GRAPH2, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(MOVE_OPERATORS);
+
    passesIgnoreStateDone.insert({ CREATE_PARALLEL_DIRS, INSERT_PARALLEL_DIRS, INSERT_SHADOW_DIRS, EXTRACT_PARALLEL_DIRS, 
                                   EXTRACT_SHADOW_DIRS, CREATE_REMOTES, UNPARSE_FILE, REMOVE_AND_CALC_SHADOW,
                                   REVERSE_CREATED_NESTED_LOOPS, PREDICT_SCHEME, CALCULATE_STATS_SCHEME, REVERT_SPF_DIRS, CLEAR_SPF_DIRS, TRANSFORM_SHADOW_IF_FULL,
--- a/src/Utils/SgUtils.cpp
+++ b/src/Utils/SgUtils.cpp
@@ -934,8 +934,14 @@ void fillNonDistrArraysAsPrivate(SgStatement *st,
        {
            auto itD = declaredArrays.find(*itSet);
            if (itD != declaredArrays.end())
-                if (itD->second.first->IsNotDistribute())
-                    privatesVars.insert(itD->second.first->GetShortName());
+            {
+                const auto array = itD->second.first;
+                if (array->IsNotDistribute())
+                {
+                    auto symb = array->GetDeclSymbol(make_pair(st->fileName(), st->lineNumber()));
+                    privatesVars.insert(symb->identifier());
+                }
+            }
        }
    }
 }
@@ -953,9 +959,21 @@ DIST::Array* getArrayFromDeclarated(SgStatement *st, const string &arrayName)
        for (auto itSet = it->second.begin(); itSet != it->second.end() && !found; ++itSet)
        {
            auto itD = declaredArrays.find(*itSet);
-            if (itD != declaredArrays.end())
-                if (itD->second.first->GetShortName() == arrayName)
-                    found = itD->second.first;
+            if (itD != declaredArrays.end()) 
+            {
+                DIST::Array* array = itD->second.first;
+                if (array->GetLocation().first == DIST::l_COMMON)
+                {
+                    auto symb = array->GetDeclSymbol(make_pair(st->fileName(), st->lineNumber()));
+                    if (symb && symb->identifier() == arrayName)
+                        found = array;
+                }
+                else
+                {
+                    if (array->GetShortName() == arrayName)
+                        found = array;
+                }
+            }
        }
    }
    return found;
@@ -1264,6 +1282,32 @@ static SgExpression* isInCommon(const vector<SgExpression*> &commonBlocks, const
    return NULL;
 }

+//all common block in project
+extern map<string, CommonBlock*> commonBlocks;
+static string getCommonNameOnPos(const string& name, const int commonPos)
+{
+    if (commonBlocks.size() == 0)
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    auto it = commonBlocks.find(name);
+    if (it == commonBlocks.end())
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    auto inPos = it->second->getGroupedVars().find(commonPos);
+    if (inPos == it->second->getGroupedVars().end())
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    set<string> namesOnPos;
+
+    for (auto& var : inPos->second)
+        namesOnPos.insert(var->getName());
+
+    if (namesOnPos.size() == 0)
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    return *namesOnPos.begin();
+}
+
 static map<tuple<string, string, int>, tuple<int, string, string>> tableOfUniqNames;
 tuple<int, string, string> getUniqName(const map<string, vector<SgExpression*>> &commonBlocks, SgStatement *decl, SgSymbol *symb)
 {
@@ -1272,6 +1316,7 @@ tuple<int, string, string> getUniqName(const map<string, vector<SgExpression*>>
    int commonPos = 0;

    SgExpression *foundCommon = NULL;
+    string symbCommn = "";

    SgStatement *declCP = decl->controlParent();
    // find symbol in parameter list of functions
@@ -1307,6 +1352,7 @@ tuple<int, string, string> getUniqName(const map<string, vector<SgExpression*>>
            if (foundCommon)
            {
                inCommon = true;
+                symbCommn = getCommonNameOnPos(common.first, commonPos);
                break;
            }
        }
@@ -1314,7 +1360,7 @@ tuple<int, string, string> getUniqName(const map<string, vector<SgExpression*>>

    tuple<int, string, string> retVal;
    if (inCommon)
-        retVal = make_tuple(commonPos, string("common_") + getCommonName(foundCommon), string(symb->identifier()));
+        retVal = make_tuple(commonPos, string("common_") + getCommonName(foundCommon), symbCommn);
    else
        retVal = make_tuple(decl->lineNumber(), string(decl->fileName()), string(symb->identifier()));

--- a/src/Utils/module_utils.cpp
+++ b/src/Utils/module_utils.cpp
@@ -337,10 +337,15 @@ const set<SgSymbol*>& getModuleSymbols(SgStatement *func)
    //if function or module in contains
    auto cp = func->controlParent();
    if (isSgProgHedrStmt(cp) || cp->variant() == MODULE_STMT)
+    {
        getModuleSymbols(cp, symbs);

+        if (func->variant() == FUNC_HEDR)
+            symbs.insert(func->symbol());
+    }
+
    symbolsForFunc[func->symbol()->identifier()] = symbs;
-    return symbs;
+    return symbolsForFunc[func->symbol()->identifier()];
 }

 static void findSymbol(SgStatement* func, const string& varName, const string& locName,
@@ -349,9 +354,19 @@ static void findSymbol(SgStatement* func, const string& varName, const string& l
    for (const auto& s : getModuleSymbols(func))
    {
        SgSymbol* orig = OriginalSymbol(s);
+        printf("%s == %s\n", orig->identifier(), s->identifier());
        //any suitable symbol can be used
-        if (orig->identifier() == varName && orig->scope()->symbol()->identifier() == locName)
-            altNames[s->identifier()] = s;
+
+        if (orig->variant() == FUNCTION_NAME)
+        {
+            if (orig->identifier() == varName)
+                altNames[s->identifier()] = s;
+        }
+        else
+        {
+            if (orig->identifier() == varName && orig->scope()->symbol()->identifier() == locName)
+                altNames[s->identifier()] = s;
+        }
    }
 }

@@ -369,6 +384,7 @@ SgSymbol* getNameInLocation(SgStatement* func, const string& varName, const stri
        return altNames.begin()->second;
    else {
        __spf_print(1, "%s (%s %s) %s\n", func->symbol()->identifier(), clearName.c_str(), varName.c_str(), locName.c_str());
+        findSymbol(func, varName, locName, altNames);
        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
    }

--- a/src/Utils/utils.cpp
+++ b/src/Utils/utils.cpp
@@ -569,8 +569,8 @@ void copyIncludes(const set<string> &allIncludeFiles, const map<string, map<int,

            while (!feof(oldFile))
            {
-                char buf[8192];
-                char *res = fgets(buf, 16384, oldFile);
+                char buf[16384];
+                char *res = fgets(buf, sizeof(buf), oldFile);
                if (res == NULL)
                    break;

--- a/src/Utils/version.h
+++ b/src/Utils/version.h
@@ -1,3 +1,3 @@
 #pragma once

-#define VERSION_SPF "2450"
+#define VERSION_SPF "2465"
--- a/src/VisualizerCalls/get_information.cpp
+++ b/src/VisualizerCalls/get_information.cpp
@@ -152,7 +152,7 @@ static void setOptions(const short* options, bool isBuildParallel = false, const
            intOptions[z] = -1;
    }

-    staticShadowAnalysis = intOptions[STATIC_SHADOW_ANALYSIS];
+    //staticShadowAnalysis = intOptions[STATIC_SHADOW_ANALYSIS];
    staticPrivateAnalysis = intOptions[STATIC_PRIVATE_ANALYSIS];
    out_free_form = intOptions[FREE_FORM];
    if (out_free_form == 1)
@@ -1802,6 +1802,13 @@ int SPF_InsertPrivateArrayDirectives(void*& context, int winHandler, short* opti
    return simpleTransformPass(FIND_PRIVATE_ARRAYS, options, projName, folderName, output, outputMessage);
 }

+int SPF_MoveOperators(void*& context, int winHandler, short* options, short* projName, short* folderName, string& output, string& outputMessage)
+{
+    MessageManager::clearCache();
+    MessageManager::setWinHandler(winHandler);
+    return simpleTransformPass(MOVE_OPERATORS, options, projName, folderName, output, outputMessage);
+}
+
 static inline void convertBackSlash(char *str, int strL)
 {
    for (int z = 0; z < strL; ++z)
@@ -2510,6 +2517,8 @@ const wstring Sapfor_RunTransformation(const char* transformName_c, const char*
        retCode = SPF_RenameIncludes(context, winHandler, optSh, projSh, fold, output, outputMessage);
    else if (whichRun == "SPF_InsertPrivateArrayDirectives")
        retCode = SPF_InsertPrivateArrayDirectives(context, winHandler, optSh, projSh, fold, output, outputMessage);
+    else if (whichRun == "SPF_MoveOperators")
+        retCode = SPF_MoveOperators(context, winHandler, optSh, projSh, fold, output, outputMessage);
    else if (whichRun == "SPF_CreateParallelVariant")
    {
        vector<string> splited;
Author	SHA1	Message	Date
Oleg Nikitin	b6665271dd	fix algorythm	2026-02-19 20:47:24 +03:00
ALEXks	68b6883f30	improved fix_common_blocks	2026-02-19 20:47:24 +03:00
ALEXks	fe81822c96	fixed getModuleSymbols	2026-02-19 20:47:24 +03:00
xnpster	2a0cfdb68e	fix some compiler warnings	2026-02-19 20:47:24 +03:00
xnpster	4229041da4	PRIVATE_ANALYSIS_IR: handle unreachable loops	2026-02-19 20:47:24 +03:00
ALEXks	14e3bc54f1	dvm updated	2026-02-19 20:47:24 +03:00
ALEXks	46ff7761d6	dvm updated	2026-02-19 20:47:23 +03:00
ALEXks	19254c0641	fixed shadow grouping	2026-02-19 20:47:23 +03:00
ALEXks	78aa84f8e5	added CFG_withUnreachable option	2026-02-19 20:47:23 +03:00
ALEXks	aa7f9cfa4f	improved CFG settings	2026-02-19 20:47:23 +03:00
ALEXks	ef76988301	turn on staticShadowAnalysis option	2026-02-19 20:47:23 +03:00
ALEXks	0b46007f8e	fixed private filling	2026-02-19 20:47:23 +03:00
ALEXks	3024a52963	fixed deps	2026-02-19 20:47:23 +03:00
ALEXks	4245afa5c8	fixed getNameInLocation for module functions	2026-02-19 20:47:23 +03:00
ALEXks	7d8c4b4714	fixed unparsing COMMON list	2026-02-19 20:47:23 +03:00
ALEXks	557c58f879	fixed GetDeclSymbol	2026-02-19 20:47:23 +03:00
ALEXks	b8d8bb9ddc	fixed ChangeName function for common	2026-02-19 20:47:23 +03:00
ALEXks	5c6a2444f3	fixed different names of same arrays in common	2026-02-19 20:47:22 +03:00
ALEXks	e958fdbc7c	fixed private analysis	2026-02-19 20:47:22 +03:00
ALEXks	390b1f7076	updated submodule libpredictor	2026-02-19 20:47:22 +03:00
ALEXks	9f3c4310ed	fixed submodule libpredictor	2026-02-19 20:47:22 +03:00
ALEXks	1c0e02dd9c	version updated	2026-02-19 20:47:22 +03:00
ALEXks	ece05bf29a	dvm submodule updated	2026-02-19 20:47:22 +03:00
ALEXks	0f4e970adf	refactored, added pass to Visualizer calls	2026-02-19 20:47:22 +03:00
ALEXks	05b72fe9b7	refactored	2026-02-19 20:47:22 +03:00
Egor Mayorov	806365daa8	fixes & improvements	2026-02-19 20:47:22 +03:00
Egor Mayorov	b27539edea	Adding handing of nested loops and conditional statements	2026-02-19 20:47:22 +03:00
Egor Mayorov	7a62268f61	Make pass correct	2026-02-19 20:47:22 +03:00
Egor Mayorov	88e9a1532e	attempt to build new ast	2026-02-19 20:47:22 +03:00
Alexander	087247b11f	moved to transformations	2026-02-19 20:47:22 +03:00
Egor Mayorov	de5c17b46f	swap operators in AST	2026-02-19 20:47:21 +03:00
Egor Mayorov	d5f70c3604	Use more complex algorythm for building new order of statements	2026-02-19 20:47:21 +03:00
Egor Mayorov	af7b343ebd	update in new order	2026-02-19 20:47:21 +03:00
Egor Mayorov	3fd03d4c2a	biulding new order	2026-02-19 20:47:21 +03:00
Egor Mayorov	aa92a918a4	some loop analysis done	2026-02-19 20:47:21 +03:00
Egor Mayorov	6f649696ab	Add _bin to gitignore	2026-02-19 20:47:21 +03:00
Egor Mayorov	e2356498dc	Some actions simplify analyzing IR	2026-02-19 20:47:21 +03:00
Egor Mayorov	55ba751dc3	Pass with output file added	2026-02-19 20:47:21 +03:00
Egor Mayorov	212460ac15	change pass deps	2026-02-19 20:47:21 +03:00
Egor Mayorov	d17b4c2702	New pass	2026-02-19 20:47:21 +03:00
Oleg Nikitin	3eb09fe5cf	change propagation	2025-12-27 13:30:25 +03:00