moved to transformations

swap operators in AST
Use more complex algorythm for building new order of statements
2025-07-09 14:46:38 +03:00 · 2025-07-09 14:46:38 +03:00 · 2025-07-09 14:46:38 +03:00 · 2025-07-09 14:46:38 +03:00 · 2025-07-09 14:46:38 +03:00 · 2025-07-09 14:46:38 +03:00
42 changed files with 1149 additions and 1540 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -78,3 +78,4 @@ Sapfor/Sapc++/x64/

 Sapfor/out/
 Sapfor/_bin/*
+_bin/*
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -12,7 +12,6 @@ add_definitions("-D SYS5")
 add_definitions("-D YYDEBUG")

 set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_C_STANDARD 17)

 set(fdvm_include    projects/dvm/fdvmh/include/fdvmh/)
 set(fdvm_sources    projects/dvm/fdvmh/tools/fdvmh/)
@@ -163,10 +162,6 @@ set(PARALLEL_REG src/ParallelizationRegions/ParRegions.cpp
        src/ParallelizationRegions/resolve_par_reg_conflicts.cpp
        src/ParallelizationRegions/resolve_par_reg_conflicts.h)

-set(ARRAY_PROP src/ArrayConstantPropagation/propagation.cpp
-	src/ArrayConstantPropagation/propagation.h	
-)
-
 set(TR_DEAD_CODE src/Transformations/DeadCodeRemoving/dead_code.cpp
        src/Transformations/DeadCodeRemoving/dead_code.h)
 set(TR_CP src/Transformations/CheckPoints/checkpoints.cpp
@@ -208,6 +203,8 @@ 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)
+SET(TR_SWAP_OPERATORS src/Transformations/SwapOperators/swap_operators.cpp
+        src/Transformations/SwapOperators/swap_operators.h)

 set(TRANSFORMS 
        ${TR_DEAD_CODE}
@@ -230,7 +227,8 @@ set(TRANSFORMS
        ${TR_REPLACE_ARRAYS_IN_IO}
        ${TR_EXPR_TRANSFORM}
        ${TR_INLINER}
-        ${TR_RENAME_SYMBOLS})
+        ${TR_RENAME_SYMBOLS}
+        ${TR_SWAP_OPERATORS})
        
 set(CFG src/CFGraph/IR.cpp
        src/CFGraph/IR.h
@@ -424,7 +422,6 @@ set(SOURCE_EXE
    ${TRANSFORMS}
    ${PARALLEL_REG}
    ${PRIV}
-    ${ARRAY_PROP}
    ${FDVM}
    ${OMEGA}
    ${UTILS}
@@ -464,6 +461,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\\SwapOperators FILES ${TR_SWAP_OPERATORS})


 source_group (CreateIntervals FILES ${CREATE_INTER_T})
@@ -476,7 +474,6 @@ source_group (GraphLoop FILES ${GR_LOOP})
 source_group (LoopAnalyzer FILES ${LOOP_ANALYZER})
 source_group (ParallelizationRegions FILES ${PARALLEL_REG})
 source_group (PrivateAnalyzer FILES ${PRIV})      
-source_group (ArrayConstantPropagation FILES ${ARRAY_PROP})      
 source_group (FDVM_Compiler FILES ${FDVM})
 source_group (SageExtension FILES ${OMEGA})
 source_group (Utils FILES ${UTILS})
@@ -493,7 +490,7 @@ source_group (Predictor\\Library FILES ${LIBPREDICTOR})
 source_group (Parser FILES ${PARSER})
 source_group (PPPA\\PPPA FILES ${PPPA})
 source_group (PPPA\\ZLib FILES ${ZLIB})
-
+   
 if (MSVC_IDE)   
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP /Zc:__cplusplus")
 else()
@@ -502,9 +499,7 @@ else()
    else()
        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
    endif()
-    if(NOT CMAKE_BUILD_TYPE)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
-    endif()
+   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2")
 endif()

 add_subdirectory(projects/Fdvm)
--- a/projects/dvm
+++ b/projects/dvm
--- a/src/ArrayConstantPropagation/propagation.cpp
+++ b/src/ArrayConstantPropagation/propagation.cpp
@@ -1,342 +0,0 @@
-#include "propagation.h"
-
-#include "../Utils/SgUtils.h"
-
-#include <iostream>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-using namespace std;
-
-static SgStatement* declPlace = NULL;
-static unordered_set<SgStatement*> changed;;
-
-static bool CheckConstIndexes(SgExpression* exp)
-{
-    if (!exp)
-    {
-        return true;
-    }
-    SgExpression* lhs = exp->lhs();
-    SgExpression* rhs = exp->rhs();
-    do
-    {
-        if (lhs->variant() != INT_VAL)
-        {
-            return false;
-        }
-        if (rhs)
-        {
-            lhs = rhs->lhs();
-            rhs = rhs->rhs();
-        }
-    } while (rhs);
-    return true;
-}
-
-static SgExpression* CreateVar(int& variableNumber, SgType* type)
-{
-    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__";
-
-    SgStatement* funcStart = declPlace->controlParent();
-    SgStatement* commonStat = NULL;
-    SgExpression* commonList = NULL;
-
-    SgStatement* funcEnd = funcStart->lastNodeOfStmt();
-    SgStatement* current = funcStart->lexNext();
-
-    while (current != funcEnd && current)
-    {
-        if (current->variant() == COMM_STAT)
-        {
-            for (SgExpression* exp = current->expr(0); exp; exp = exp->rhs())
-            {
-                if (exp->variant() == COMM_LIST)
-                {
-                    string existingName = exp->symbol() ?
-                        string(exp->symbol()->identifier()) :
-                        string("spf_unnamed");
-                    if (existingName == commonBlockName)
-                    {
-                        commonStat = current;
-                        commonList = exp;
-                        break;
-                    }
-                }
-            }
-            if (commonStat)
-                break;
-        }
-        current = current->lexNext();
-    }
-
-    vector<SgExpression*> varRefs;
-    if (commonList)
-    {
-        SgExpression* varList = commonList->lhs();
-        if (varList)
-        {
-            auto extractSymbol = [](SgExpression* exp) -> SgSymbol* {
-                if (!exp) 
-                    return NULL;
-                if (exp->symbol()) 
-                    return exp->symbol();
-                if (exp->lhs() && exp->lhs()->symbol())
-                    return exp->lhs()->symbol();
-                return NULL;
-                };
-            if (varList->variant() == EXPR_LIST)
-            {
-                for (SgExpression* exp = varList; exp; exp = exp->rhs())
-                {
-                    SgExpression* varExp = exp->lhs();
-                    SgSymbol* sym = extractSymbol(varExp);
-                    if (sym)
-                    {
-                        varRefs.push_back(new SgVarRefExp(sym));
-                    }
-                }
-            }
-            else
-            {
-                for (SgExpression* varExp = varList; varExp; varExp = varExp->rhs())
-                {
-                    SgSymbol* sym = extractSymbol(varExp);
-                    if (sym)
-                    {
-                        varRefs.push_back(new SgVarRefExp(sym));
-                    }
-                }
-            }
-        }
-    }
-
-    if (!commonList)
-    {
-        current = funcStart->lexNext();
-        while (current != funcEnd && current)
-        {
-            if (current->variant() == COMM_STAT)
-            {
-                commonStat = current;
-                break;
-            }
-            current = current->lexNext();
-        }
-
-        SgSymbol* commonSymbol = new SgSymbol(COMMON_NAME, commonBlockName.c_str());
-        commonList = new SgExpression(COMM_LIST, NULL, NULL, commonSymbol);
-
-        if (commonStat)
-        {
-            SgExpression* lastCommList = commonStat->expr(0);
-            if (lastCommList)
-            {
-                while (lastCommList->rhs())
-                    lastCommList = lastCommList->rhs();
-                lastCommList->setRhs(commonList);
-            }
-            else
-            {
-                commonStat->setExpression(0, commonList);
-            }
-        }
-        else
-        {
-            commonStat = new SgStatement(COMM_STAT);
-            commonStat->setFileName(declPlace->fileName());
-            commonStat->setFileId(declPlace->getFileId());
-            commonStat->setProject(declPlace->getProject());
-            commonStat->setlineNumber(getNextNegativeLineNumber());
-            commonStat->setExpression(0, commonList);
-
-            declPlace->insertStmtBefore(*commonStat, *declPlace->controlParent());
-        }
-
-    }
-    varRefs.push_back(new SgVarRefExp(varSymbol));
-
-    if (varRefs.size() > 0)
-    {
-        std::reverse(varRefs.begin(), varRefs.end());
-        SgExpression* varList = makeExprList(varRefs, false);
-
-        commonList->setLhs(varList);
-    }
-    return  new SgExpression(VAR_REF, NULL, NULL, varSymbol, type->copyPtr());
-}
-
-static void TransformRightPart(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber) 
-{
-    if (!exp)
-    {
-        return;
-    }
-
-    vector<SgExpression*> subnodes = { exp->lhs(), exp->rhs() };
-
-    string expUnparsed;
-    SgExpression* toAdd = NULL;
-    if (exp->variant() == ARRAY_REF && CheckConstIndexes(exp->lhs()))
-    {
-        cout << st->unparse() << endl;
-        if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
-        {
-            arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());  
-        }
-        st->setExpression(1, arrayToVariable[expUnparsed]->copyPtr());
-        return;
-    }
-    for (int i = 0; i < 2; i++)
-    {
-        if (subnodes[i] && subnodes[i]->variant() == ARRAY_REF && subnodes[i]->symbol()->type()->baseType() && CheckConstIndexes(subnodes[i]->lhs()))
-        {
-            expUnparsed = subnodes[i]->unparse();
-            if (arrayToVariable.find(expUnparsed) == arrayToVariable.end())
-            {                
-                arrayToVariable[expUnparsed] = CreateVar(variableNumber, subnodes[i]->symbol()->type()->baseType());;
-            }
-            toAdd = arrayToVariable[expUnparsed]->copyPtr();
-            if (toAdd)
-            {
-                if (i == 0)
-                {
-                    exp->setLhs(toAdd);
-                }
-                else
-                {
-                    exp->setRhs(toAdd);
-                }
-            }
-        }
-        else
-        {
-            TransformRightPart(st, subnodes[i], arrayToVariable, variableNumber);
-        }
-    }
-}
-
-static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<string, SgExpression*>& arrayToVariable, int& variableNumber)
-{
-    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())
-    {
-        arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
-    }
-    SgStatement* newStatement = new SgStatement(ASSIGN_STAT, NULL, NULL, arrayToVariable[expUnparsed]->copyPtr(), st->expr(1)->copyPtr(), NULL);
-
-   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) 
-{
-    unordered_map<string, SgExpression*> arrayToVariable;
-    int variableNumber = 0;
-    for (int i = 0; i < project.numberOfFiles(); i++) 
-    {
-        SgFile* file = &(project.file(i));
-
-        if (!file)
-            continue;
-
-        const int funcNum = file->numberOfFunctions();
-        for (int i = 0; i < funcNum; ++i)
-        {
-            SgStatement* st = file->functions(i);
-            declPlace = st->lexNext();
-            SgStatement* lastNode = st->lastNodeOfStmt();
-
-            for (; st != lastNode; st = st->lexNext())
-            {
-                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()))
-                    {
-                        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()))
-                    {
-                        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/ArrayConstantPropagation/propagation.h
+++ b/src/ArrayConstantPropagation/propagation.h
@@ -1,4 +0,0 @@
-#pragma once
-#include "../Utils/SgUtils.h"
-
-void ArrayConstantPropagation(SgProject& project);
--- a/src/DirectiveProcessing/shadow.cpp
+++ b/src/DirectiveProcessing/shadow.cpp
@@ -15,7 +15,7 @@
 #include "SgUtils.h"
 #include "expr_transform.h"

-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"

 #include "shadow.h"
 #include "dvm.h"
--- a/src/Distribution/ArrayAnalysis.cpp
+++ b/src/Distribution/ArrayAnalysis.cpp
@@ -241,15 +241,13 @@ static void findArrayRefs (SgExpression* ex, SgStatement* st, string fName, int
                itNew->second.first->SetRegionPlace(reg);

            const auto oldVal = itNew->second.first->GetDistributeFlagVal();
-            bool isArrayInModule = (itNew->second.first->GetLocation().first == DIST::l_MODULE);
+            bool isarrayInModule = (itNew->second.first->GetLocation().first == DIST::l_MODULE);

            if (oldVal == DIST::DISTR || oldVal == DIST::NO_DISTR)
            {
                if (itNew->second.first->IsOmpThreadPrivate())
                    itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
-                else if (deprecatedByIO.find(symb->identifier()) != deprecatedByIO.end())
-                    itNew->second.first->SetDistributeFlag(DIST::IO_PRIV);
-                else if (isArrayInModule || privates.find(symb->identifier()) != privates.end())
+                else if (privates.find(symb->identifier()) != privates.end() || isarrayInModule)
                {
                    //check in module
                    if (itNew->second.first->GetLocation().first == DIST::l_MODULE)
@@ -276,6 +274,8 @@ static void findArrayRefs (SgExpression* ex, SgStatement* st, string fName, int
                    else
                        itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
                }
+                else if (deprecatedByIO.find(symb->identifier()) != deprecatedByIO.end())
+                    itNew->second.first->SetDistributeFlag(DIST::IO_PRIV);
                else if (isSgConstantSymb(symb) || inDataStat)
                    itNew->second.first->SetDistributeFlag(DIST::SPF_PRIV);
                else
--- a/src/Distribution/CreateDistributionDirs.cpp
+++ b/src/Distribution/CreateDistributionDirs.cpp
@@ -274,7 +274,7 @@ static void convertTrees(const map<DIST::Array*, int> &treesIn, map<int, vector<
 static DIST::Array* findBestInEqual(vector<DIST::Array*> &arrays, DIST::GraphCSR<int, double, attrType> &reducedG, DIST::Arrays<int> &allArrays)
 {
    DIST::Array *retVal = NULL;
-    vector<vector<attrType>> coeffsByDims;
+    vector<vector<attrType>> coefsByDims;
    for (auto &array : arrays)
    {
        vector<int> verts;
@@ -285,7 +285,7 @@ static DIST::Array* findBestInEqual(vector<DIST::Array*> &arrays, DIST::GraphCSR
        {
            retVal = array;
            for (auto &V : verts)
-                coeffsByDims.push_back(reducedG.GetAllAttributes(V));
+                coefsByDims.push_back(reducedG.GetAllAttributes(V));
        }
        else
        {
@@ -294,11 +294,11 @@ static DIST::Array* findBestInEqual(vector<DIST::Array*> &arrays, DIST::GraphCSR
                toCmp.push_back(reducedG.GetAllAttributes(V));
            for (int z = 0; z < toCmp.size(); ++z)
            {
-                if (toCmp[z].size() && coeffsByDims[z].size())
+                if (toCmp[z].size() && coefsByDims[z].size())
                {
-                    if (toCmp[z].back().first.first > coeffsByDims[z].back().first.first)
+                    if (toCmp[z].back().first.first > coefsByDims[z].back().first.first)
                    {
-                        coeffsByDims = toCmp;
+                        coefsByDims = toCmp;
                        retVal = array;
                        break;
                    }
--- a/src/Distribution/DvmhDirective.cpp
+++ b/src/Distribution/DvmhDirective.cpp
@@ -45,10 +45,10 @@ static bool findArrayRefAndCheck(SgExpression *ex, const DIST::Array* currArray,
                int countOfShadows = 0;
                for (int i = 0; i < ref->numberOfSubscripts(); ++i)
                {
-                    const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
-                    if (coeffs.size() == 1)
+                    const vector<int*> &coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
+                    if (coefs.size() == 1)
                    {
-                        const pair<int, int> coef(coeffs[0][0], coeffs[0][1]);
+                        const pair<int, int> coef(coefs[0][0], coefs[0][1]);
                        auto it = shiftsByAccess[i].find(coef);
                        if (it != shiftsByAccess[i].end())
                            if (it->second != 0)
--- a/src/Distribution/DvmhDirectiveBase.cpp
+++ b/src/Distribution/DvmhDirectiveBase.cpp
@@ -364,11 +364,11 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
            {
                if (sharedMemoryParallelization)
                {
-                    for (auto& coeffs : currReadOp->first[k].coefficients)
+                    for (auto& coefs : currReadOp->first[k].coefficients)
                    {
-                        auto currAccess = coeffs.first;
+                        auto currAccess = coefs.first;

-                        const int currShift = coeffs.first.second;
+                        const int currShift = coefs.first.second;

                        auto itFound = shiftsByAccess[k].find(currAccess);
                        if (itFound == shiftsByAccess[k].end())
@@ -393,9 +393,9 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
                            int minShift = 9999999;
                            int maxShift = -9999999;

-                            for (auto &coeffs : currReadOp->first[k].coefficients)
+                            for (auto &coefs : currReadOp->first[k].coefficients)
                            {
-                                auto currAccess = coeffs.first;
+                                auto currAccess = coefs.first;
                                auto result = DIST::Fx(currAccess, currRuleShadow);

                                if (result.first == loopRule.first)
@@ -417,7 +417,7 @@ static inline string calculateShifts(DIST::GraphCSR<int, double, attrType> &redu
                                    auto it = remoteRegularReads.find(calcForArray);
                                    if (it == remoteRegularReads.end())
                                        it = remoteRegularReads.insert(it, make_pair(calcForArray, vector<ArrayOp>(calcForArray->GetDimSize())));
-                                    it->second[k].coefficients.insert(coeffs);
+                                    it->second[k].coefficients.insert(coefs);
                                }
                            }

--- a/src/DvmhRegions/DvmhRegionInserter.cpp
+++ b/src/DvmhRegions/DvmhRegionInserter.cpp
@@ -1297,10 +1297,7 @@ static set<DIST::Array*>
                {
                    declStat = SgStatement::getStatementByFileAndLine(decl.first, decl.second);
                    if (declStat == NULL) // check in inlcudes 
-                    {
-                        if (!main->switchToFile())
-                            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
+                    {                        
                        for (auto st = main; st != main->lastNodeOfStmt() && !declStat; st = st->lexNext())
                        {
                            if (st->fileName() == decl.first && st->lineNumber() == decl.second)
--- a/src/GraphCall/graph_calls.cpp
+++ b/src/GraphCall/graph_calls.cpp
@@ -14,7 +14,7 @@
 #include "dvm.h"
 #include "graph_calls_func.h"

-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 #include "graph_loops_func.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "SgUtils.h"
--- a/src/GraphLoop/graph_loops_base.cpp
+++ b/src/GraphLoop/graph_loops_base.cpp
@@ -1137,9 +1137,9 @@ static bool isMapped(const vector<ArrayOp> &allOps)
    bool mapped = false;
    for (auto &ops : allOps)
    {
-        for (auto &coeffs : ops.coefficients)
+        for (auto &coefs : ops.coefficients)
        {
-            if (coeffs.first.first != 0)
+            if (coefs.first.first != 0)
            {
                mapped = true;
                break;
--- a/src/LoopAnalyzer/loop_analyzer.cpp
+++ b/src/LoopAnalyzer/loop_analyzer.cpp
@@ -247,7 +247,7 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
        }
    }

-    pair<int, int> coeffs = pair<int, int>(0, 0);
+    pair<int, int> coefs = pair<int, int>(0, 0);
    // more than one loop symbol in subscription
    if (countOfSymbols > 1)
    {
@@ -326,16 +326,16 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
        {
            if (subscr->symbol()->id() == (parentLoops[position]->doName())->id())
            {
-                coeffs.first = 1;
+                coefs.first = 1;
                needToCacl = false;
            }
        }

        if (needToCacl)
-            getCoefsOfSubscript(coeffs, subscr, parentLoops[position]->doName());
-        __spf_print(PRINT_ARRAY_ARCS, " <%d %d> ", coeffs.first, coeffs.second);
+            getCoefsOfSubscript(coefs, subscr, parentLoops[position]->doName());
+        __spf_print(PRINT_ARRAY_ARCS, " <%d %d> ", coefs.first, coefs.second);

-        if (coeffs.first == 0) // && coeffs.second == 0)
+        if (coefs.first == 0) // && coefs.second == 0)
        {
            if (currRegime == REMOTE_ACC)
            {
@@ -346,7 +346,7 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
            {                
                const pair<bool, string> &arrayRefString = constructArrayRefForPrint(arrayRef, dimNum, origSubscr);
                __spf_print(1, "WARN: can not calculate index expression for array ref '%s' at line %d\n", arrayRefString.second.c_str(), currLine);
-                addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, UNREC_OP, numOfSubscriptions, currentW);
+                addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, UNREC_OP, numOfSubscriptions, currentW);
                if (side == LEFT)
                    allPositions.clear();

@@ -371,19 +371,19 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
                        currOp.resize(numOfSubscriptions);

                    //add only uniq 
-                    auto itAdd = currOp[dimNum].coefficients.find(coeffs);
+                    auto itAdd = currOp[dimNum].coefficients.find(coefs);
                    if (itAdd == currOp[dimNum].coefficients.end())
-                        itAdd = currOp[dimNum].coefficients.insert(itAdd, make_pair(coeffs, currentW));
+                        itAdd = currOp[dimNum].coefficients.insert(itAdd, make_pair(coefs, currentW));
                }

-                if (coeffs.first < 0)
+                if (coefs.first < 0)
                    addInfoToMap(loopInfo, parentLoops[position], currOrigArrayS, arrayRef, dimNum, REMOTE_TRUE, currLine, numOfSubscriptions);
                else
                    //if we found regular access to array - set it false
                    addInfoToMap(loopInfo, parentLoops[position], currOrigArrayS, arrayRef, dimNum, REMOTE_FALSE, currLine, numOfSubscriptions);
            }

-            if (coeffs.first < 0 && sharedMemoryParallelization == 0)
+            if (coefs.first < 0 && sharedMemoryParallelization == 0)
            {
                if (currRegime == DATA_DISTR)
                {
@@ -402,15 +402,15 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
                    if (side == LEFT)
                        allPositions.clear();
                    else
-                        addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, UNREC_OP, numOfSubscriptions, currentW);
+                        addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, UNREC_OP, numOfSubscriptions, currentW);
                }
            }
            else
            {
                if (side == LEFT)
-                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, WRITE_OP, numOfSubscriptions, currentW);
+                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, WRITE_OP, numOfSubscriptions, currentW);
                else
-                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coeffs, READ_OP, numOfSubscriptions, currentW);
+                    addInfoToVectors(loopInfo, parentLoops[position], currOrigArrayS, dimNum, coefs, READ_OP, numOfSubscriptions, currentW);
            }
        }
    }
@@ -418,13 +418,13 @@ static vector<int> matchSubscriptToLoopSymbols(const vector<SgForStmt*> &parentL
    if (currRegime == ARRAY_ACC_CORNER)
    {
        int *valueSubs = new int[2];
-        valueSubs[0] = coeffs.first;
-        valueSubs[1] = coeffs.second;
+        valueSubs[0] = coefs.first;
+        valueSubs[1] = coefs.second;
 #ifdef __SPF
        addToCollection(__LINE__, __FILE__, valueSubs, 2);
 #endif
-        const vector<int*> &coeffs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
-        if (coeffs.size() == 0)
+        const vector<int*> &coefs = getAttributes<SgExpression*, int*>(subscr, set<int>{ INT_VAL });
+        if (coefs.size() == 0)
        {
            subscr->addAttribute(INT_VAL, valueSubs, sizeof(int*));
            if (position != -1 && allPositions.size() == 1 && position < parentLoops.size())
--- a/src/Predictor/PredictScheme.cpp
+++ b/src/Predictor/PredictScheme.cpp
@@ -22,7 +22,7 @@
 #include "graph_loops_func.h"
 #include "expr_transform.h"
 #include "../LoopAnalyzer/loop_analyzer.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"

 #include "json.hpp"

@@ -326,7 +326,7 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
        list = list->rhs();
    }

-    vector<pair<int, int>> coeffs(srcSymbs.size());
+    vector<pair<int, int>> coefs(srcSymbs.size());
    list = listTgt;
    while (list)
    {
@@ -337,8 +337,8 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
            has = recSymbolFind(exp, srcSymbs[z].first, VAR_REF);
            if (has)
            {
-                getCoefsOfSubscript(coeffs[z], exp, srcSymbs[z].second);
-                if (coeffs[z].first == 0)
+                getCoefsOfSubscript(coefs[z], exp, srcSymbs[z].second);
+                if (coefs[z].first == 0)
                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
                break;
            }
@@ -346,14 +346,14 @@ static json parseAlign(const map<DIST::Array*, int>& byPos, SgSymbol* srcArr, Sg
        list = list->rhs();
    }

-    for (int z = 0; z < coeffs.size(); ++z)
+    for (int z = 0; z < coefs.size(); ++z)
    {
-        if (coeffs[z].first == 0)
+        if (coefs[z].first == 0)
            continue;
-        if (coeffs[z].second)
-            align["rules"].push_back({ z, coeffs[z].first });
+        if (coefs[z].second)
+            align["rules"].push_back({ z, coefs[z].first });
        else
-            align["rules"].push_back({ z, coeffs[z].first, coeffs[z].second });
+            align["rules"].push_back({ z, coefs[z].first, coefs[z].second });
    }
    return align;
 }
--- a/src/PrivateAnalyzer/private_analyzer.cpp
+++ b/src/PrivateAnalyzer/private_analyzer.cpp
@@ -12,7 +12,7 @@
 #include "graph_calls.h"
 #include "private_analyzer.h"
 #include "dvm.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"

 using std::vector;

--- a/src/PrivateAnalyzer/private_arrays_search.cpp
+++ b/src/PrivateAnalyzer/private_arrays_search.cpp
@@ -11,40 +11,11 @@
 #include "region.h"
 #include "SgUtils.h"
 #include "graph_loops.h"
-#include "CFGraph/CFGraph.h"
-#include "utils.h"
+#include "../CFGraph/CFGraph.h"

 using namespace std;

-static void RemoveEmptyPoints(ArrayAccessingIndexes& container)
-{
-    ArrayAccessingIndexes resultContainer;
-    unordered_set<string> toRemove;
-
-    for (auto& [arrayName, accessingSet] : container)
-    {
-        vector<vector<ArrayDimension>> points;
-        for (auto& arrayPoint : accessingSet.GetElements())
-        {
-            if (!arrayPoint.empty())
-                points.push_back(arrayPoint);
-        }
-
-        if (points.size() < accessingSet.GetElements().size() && !points.empty())
-            resultContainer[arrayName] = points;
-
-        if (points.empty())
-            toRemove.insert(arrayName);
-    }
-
-    for (const string& name : toRemove)
-        container.erase(name);
-
-    for (auto& [arrayName, accessingSet] : resultContainer)
-        container[arrayName] = accessingSet;
-}
-
-static void Collapse(Region* region)
+void Collapse(Region* region)
 {
    if (region->getBasickBlocks().empty())
        return;
@@ -66,15 +37,13 @@ static void Collapse(Region* region)
            region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
        }
    }
-
-    ArrayAccessingIndexes useUnionB;
+    ArrayAccessingIndexes useUnion;
    for (auto& byBlock : region->getBasickBlocks())
-        for (auto& [arrayName, _] : byBlock->array_use)
-            useUnionB[arrayName] = useUnionB[arrayName].Union(byBlock->array_use[arrayName]);
-
-    for (auto& [arrayName, _] : useUnionB)
-        region->array_priv[arrayName] = useUnionB[arrayName].Diff(region->array_use[arrayName]);
+        for (auto& [arrayName, arrayRanges] : byBlock->array_use)
+            useUnion[arrayName] = useUnion[arrayName].Union(byBlock->array_use[arrayName]);

+    for (auto& [arrayName, arrayRanges] : useUnion)
+        region->array_priv[arrayName] = useUnion[arrayName].Diff(region->array_use[arrayName]);
    
    for (Region* prevBlock : region->getHeader()->getPrevRegions()) 
        prevBlock->replaceInNextRegions(region, region->getHeader());
@@ -105,7 +74,6 @@ static void SolveDataFlowIteratively(Region* DFG)
                    newIn.clear();
                    continue;
                }
-
                for (const auto& [arrayName, accessSet] : prevBlock->array_out)
                {
                    if (newIn.find(arrayName) != newIn.end())
@@ -118,7 +86,6 @@ static void SolveDataFlowIteratively(Region* DFG)

        b->array_in = move(newIn);
        ArrayAccessingIndexes newOut;
-
        if (b->array_def.empty())        
            newOut = b->array_in;
        else if (b->array_in.empty())
@@ -154,83 +121,21 @@ static void SolveDataFlow(Region* DFG)
    Collapse(DFG);
 }

-static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes& privates, set<SgStatement*>& insertedPrivates)
-{
-    SgStatement* spfStat = new SgStatement(SPF_ANALYSIS_DIR);
-    spfStat->setlineNumber(loop->loop->lineNumber());
-    spfStat->setFileName(loop->loop->fileName());
-    SgExpression* toAdd = new SgExpression(EXPR_LIST, new SgExpression(ACC_PRIVATE_OP), NULL, NULL);
-    set<SgSymbol*> arraysToInsert;
-    for (const auto& [_, accessingSet] : privates)
-    {
-        for (const auto& arrayElement : accessingSet.GetElements())
-        {
-            if (arrayElement.empty())
-                continue;
-            arraysToInsert.insert(arrayElement[0].array->symbol());
-        }
-    }
-
-    spfStat->setExpression(0, *toAdd);
-    toAdd = toAdd->lhs();
-    bool first = true;
-    for (auto& elem : arraysToInsert)
-    {
-        if (first)
-        {
-            toAdd->setLhs(new SgExpression(EXPR_LIST));
-            toAdd = toAdd->lhs();
-            first = false;
-        }
-        else
-        {
-            toAdd->setRhs(new SgExpression(EXPR_LIST));
-            toAdd = toAdd->rhs();
-        }
-        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);
-}
-
-void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, set<SgStatement*> &insertedPrivates)
+map<LoopGraph*, ArrayAccessingIndexes>  FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
 {  
    map<LoopGraph*, ArrayAccessingIndexes> result;
-    for (const auto& [fileName, loops] : loopGraph)
+    for (const auto& [loopName, loops] : loopGraph)
    {
-        SgFile::switchToFile(fileName);
        for (const auto& loop : loops)
        {
-            if (!loop->isFor())
-                continue;
-            SgStatement* search_func = loop->loop->GetOriginal();
-
-            while (search_func && (!isSgProgHedrStmt(search_func)))
-                search_func = search_func->controlParent();
-
            for (const auto& [funcInfo, blocks]: FullIR)
            {   
-                if (funcInfo->fileName == fileName && funcInfo->funcPointer->GetOriginal() == search_func)
-                {
-                    Region* loopRegion = new Region(loop, blocks);
-                    if (loopRegion->getBasickBlocks().size() <= 1)
-                    {
-                        delete(loopRegion);
-                        continue;
-                    }
-                    SolveDataFlow(loopRegion);
-                    RemoveEmptyPoints(loopRegion->array_priv);
-                    result[loop] = loopRegion->array_priv;
-                    delete(loopRegion);
-                }
+                Region* loopRegion = new Region(loop, blocks);
+                SolveDataFlow(loopRegion);
+                result[loop] = loopRegion->array_priv;
+                delete(loopRegion);
            }
-
-            if (result.find(loop) != result.end() && !result[loop].empty())
-                AddPrivateArraysToLoop(loop, result[loop], insertedPrivates);
        }
    }
+    return result;
 }
--- a/src/PrivateAnalyzer/private_arrays_search.h
+++ b/src/PrivateAnalyzer/private_arrays_search.h
@@ -2,12 +2,13 @@

 #include <vector>
 #include <map>
-#include <set>
 #include <unordered_set>

 #include "range_structures.h"
+#include "region.h"
 #include "graph_loops.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"

-void FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, std::set<SgStatement*>& insertedPrivates);
+void Collapse(Region* region);
+std::map<LoopGraph*, ArrayAccessingIndexes> FindPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR);
 std::pair<SAPFOR::BasicBlock*, std::unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*> blocks);
--- a/src/PrivateAnalyzer/range_structures.cpp
+++ b/src/PrivateAnalyzer/range_structures.cpp
@@ -47,7 +47,7 @@ static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const A
    
    uint64_t start3 = dim1.start + x0 * dim1.step;
    uint64_t step3 = c * dim1.step;
-    ArrayDimension* result = new(ArrayDimension){ start3, step3, tMax + 1 , dim1.array};
+    ArrayDimension* result = new(ArrayDimension){ start3, step3, tMax + 1 };
    return result;
 }

@@ -61,16 +61,21 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
    vector<ArrayDimension> result;
    /* add the part before intersection */
    if (dim1.start < intersection->start)    
-        result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step, dim1.array});
+        result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step });
    
    /* add the parts between intersection steps */
-    if (intersection->step > dim1.step)
+    uint64_t start = (intersection->start - dim1.start) / dim1.step;
+    uint64_t interValue = intersection->start;
+    for (int64_t i = start; dim1.start + i * dim1.step <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
    {
-        uint64_t start = (intersection->start - dim1.start) / dim1.step;
-        uint64_t interValue = intersection->start;
-        for (int64_t i = start; interValue <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
+        uint64_t centerValue = dim1.start + i * dim1.step;
+        if (centerValue == interValue)
        {
-            result.push_back({interValue + dim1.step, dim1.step, intersection->step / dim1.step, dim1.array});
+            if (i - start > 1)
+            {
+                result.push_back({ dim1.start + (start + 1) * dim1.step, dim1.step, i - start - 1 });
+                start = i;
+            }
            interValue += intersection->step;
        }
    }
@@ -80,7 +85,7 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
        /* first value after intersection */
        uint64_t right_start = intersection->start + intersection->step * (intersection->tripCount - 1) + dim1.step;
        uint64_t tripCount = (dim1.start + dim1.step * dim1.tripCount - right_start) / dim1.step;
-        result.push_back({ right_start, dim1.step, tripCount, dim1.array });
+        result.push_back({ right_start, dim1.step, tripCount });
    }
    delete(intersection);
    return result;
@@ -211,10 +216,6 @@ void AccessingSet::Insert(const vector<ArrayDimension>& element)
 }

 AccessingSet AccessingSet::Union(const AccessingSet& source) {
-    if (source.GetElements().empty())
-        return *this;
-    if (allElements.empty())
-        return source;
    AccessingSet result;
    for (auto& element : source.GetElements())
        result.Insert(element);
--- a/src/PrivateAnalyzer/range_structures.h
+++ b/src/PrivateAnalyzer/range_structures.h
@@ -6,12 +6,9 @@
 #include <string>
 #include <cstdint>

-#include "SgUtils.h"
-
 struct ArrayDimension
 {
    uint64_t start, step, tripCount;
-    SgArrayRefExp* array;
 };

 class AccessingSet {
--- a/src/PrivateAnalyzer/region.cpp
+++ b/src/PrivateAnalyzer/region.cpp
@@ -4,12 +4,10 @@
 #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;
@@ -106,33 +104,15 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces

        auto operation = instruction->getInstruction()->getOperation();
        auto type = instruction->getInstruction()->getArg1()->getType();
-        if (operation == SAPFOR::CFG_OP::ASSIGN && instruction->getInstruction()->getResult()->getType() == SAPFOR::CFG_ARG_TYPE::ARRAY)
-        {
-            SgStatement* op = instruction->getInstruction()->getOperator();
-            if (op && op->expr(0) && isArrayRef(op->expr(0)) && op->expr(0)->symbol() && op->expr(0)->type())
-            {
-                if (isSgArrayType(op->expr(0)->symbol()->type()))
-                {
-                    SgArrayType* arrayType = (SgArrayType*)op->expr(0)->symbol()->type();
-                    int dimCount = ((SgArrayType*)op->expr(0)->symbol()->type())->dimension();
-                    vector<ArrayDimension> point;
-                    for (int i = 0; i < dimCount; i++)
-                    {
-                        string strDimLength = arrayType->sizeInDim(i)->unparse();
-                        if (arrayType->sizeInDim(i)->variant() == INT_VAL && strDimLength != "0")
-                            point.push_back({ 1ULL, 1ULL, (uint64_t)stoi(strDimLength), (SgArrayRefExp*)op->expr(0) });
-                    }
-
-                    if (point.size() == dimCount)
-                        def[instruction->getInstruction()->getResult()->getValue()] = AccessingSet({point});
-                }
-            }
-        }
        if ((operation == SAPFOR::CFG_OP::STORE || operation == SAPFOR::CFG_OP::LOAD) && type == SAPFOR::CFG_ARG_TYPE::ARRAY)
        {
            vector<SAPFOR::Argument*> index_vars;
            vector<int> refPos;
-            string array_name = instruction->getInstruction()->getArg1()->getValue();
+            string array_name;
+            if (operation == SAPFOR::CFG_OP::STORE)
+                array_name = instruction->getInstruction()->getArg1()->getValue();            
+            else
+                array_name = instruction->getInstruction()->getArg2()->getValue();

            int j = i - 1;
            while (j >= 0 && instructions[j]->getInstruction()->getOperation() == SAPFOR::CFG_OP::REF)
@@ -147,10 +127,7 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
            vector<ArrayDimension> accessPoint(n);

            auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression());
-            int fillCount = 0;
-
            vector<pair<int, int>> coefsForDims;
-            int subs = ref->numberOfSubscripts();
            for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i)
            {
                const vector<int*>& coefs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
@@ -161,15 +138,18 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                }

            }
-            coefsForDims = {coefsForDims.rbegin(), coefsForDims.rend()};

-            while (!index_vars.empty() && !refPos.empty() && !coefsForDims.empty())
+            if(coefsForDims.empty())
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            while (!index_vars.empty())
            {
                auto var = index_vars.back();
                int currentVarPos = refPos.back();
+                pair<int, int> currentCoefs = coefsForDims.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 };
                else
                {
                    string name, full_name = var->getValue();
@@ -195,29 +175,21 @@ static int GetDefUseArray(SAPFOR::BasicBlock* block, LoopGraph* loop, ArrayAcces
                            return -1;
                    }

-                    uint64_t start = coefsForDims.back().second * currentLoop->startVal + coefsForDims.back().first;
-                    uint64_t step = currentLoop->stepVal;
-                    uint64_t iters = currentLoop->calculatedCountOfIters;
-                    current_dim = { start, step, iters, ref };
+                    uint64_t start = currentLoop->startVal * currentCoefs.first + currentCoefs.second;
+                    uint64_t step = currentCoefs.first;
+                    current_dim = { start, step, (uint64_t)currentLoop->calculatedCountOfIters };
                }

-                if (current_dim.start != 0 && current_dim.step != 0 && current_dim.tripCount != 0)
-                {
-                    accessPoint[n - index_vars.size()] = current_dim;
-                    fillCount++;
-                }
+                accessPoint[n - index_vars.size()] = current_dim;
                index_vars.pop_back();
                refPos.pop_back();
                coefsForDims.pop_back();
            }

-            if (fillCount == accessPoint.size())
-            {
-                if (operation == SAPFOR::CFG_OP::STORE)
-                    def[array_name].Insert(accessPoint);
-                else
-                    use[array_name].Insert(accessPoint);
-            }
+            if (operation == SAPFOR::CFG_OP::STORE)            
+                def[array_name].Insert(accessPoint);
+            else
+                use[array_name].Insert(accessPoint);
        }
    }
    return 0;
@@ -255,11 +227,8 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
            region->addBasickBlocks(bbToRegion.at(block));

    for (LoopGraph* childLoop : loop->children)
-    {
-        if (!childLoop->isFor())
-            continue;
        region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion));
-    }
+
    return region;
 }

@@ -278,9 +247,5 @@ Region::Region(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks)
    SetConnections(bbToRegion, blockSet);
    //create subRegions
    for (LoopGraph* childLoop : loop->children)
-    {
-        if (!childLoop->isFor())
-            continue;
        subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion));
-    }
 }
--- a/src/PrivateAnalyzer/region.h
+++ b/src/PrivateAnalyzer/region.h
@@ -6,7 +6,7 @@
 #include <string>

 #include "graph_loops.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"

 class Region : public SAPFOR::BasicBlock {
 public:
--- a/src/ProjectManipulation/ConvertFiles.cpp
+++ b/src/ProjectManipulation/ConvertFiles.cpp
@@ -403,7 +403,7 @@ static int convertFile(int argc, char* argv[], const set<string>& filesInProj, c
            fprintf(stderr, "<<<<<  Unparsing   %s  >>>>>\n", fout_name);

        if (mod_gpu) /*ACC*/
-            UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info, fout_name);
+            UnparseTo_CufAndCu_Files(file, fout_cuf, fout_C_cu, fout_info);

        const string fileN = file->filename();
        set<SgStatement*> toRemove;
--- a/src/Sapfor.cpp
+++ b/src/Sapfor.cpp
@@ -46,7 +46,6 @@
 #include "DynamicAnalysis/gCov_parser_func.h"
 #include "DynamicAnalysis/createParallelRegions.h"

-#include "ArrayConstantPropagation/propagation.h"
 #include "DirectiveProcessing/directive_analyzer.h"
 #include "DirectiveProcessing/directive_creator.h"
 #include "DirectiveProcessing/insert_directive.h"
@@ -90,6 +89,7 @@
 #include "Transformations/DeadCodeRemoving/dead_code.h"
 #include "Transformations/RenameSymbols/rename_symbols.h"
 #include "Transformations/FunctionInlining/inliner.h"
+#include "Transformations/SwapOperators/swap_operators.h"

 #include "ProjectParameters/projectParameters.h"

@@ -280,8 +280,7 @@ static string unparseProjectIfNeed(SgFile* file, const int curr_regime, const bo
            for (SgStatement* st = file->firstStatement(); st; st = st->lexNext())
                if (isSPF_stat(st)) // except sapfor parallel regions and if attributes dont move
                    if (st->variant() != SPF_PARALLEL_REG_DIR && st->variant() != SPF_END_PARALLEL_REG_DIR)
-                        if (insertedPrivates.find(st) == insertedPrivates.end())
-                            toDel.push_back(st);
+                        toDel.push_back(st);

            for (auto& elem : toDel)
                elem->deleteStmt();
@@ -941,6 +940,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                    internalExit = err;
            }
        }
+        else if (curr_regime == SWAP_OPERATORS)        
+            runSwapOperators(file, loopGraph, fullIR, countOfTransform);        
        else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
        {
            auto itFound = loopGraph.find(file->filename());
@@ -1021,6 +1022,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
                if(func->funcPointer->variant() != ENTRY_STAT)
                    countOfTransform += removeDeadCode(func->funcPointer, allFuncInfo, commonBlocks);
        }
+        else if (curr_regime == FIND_PRIVATE_ARRAYS)
+            FindPrivateArrays(loopGraph, fullIR);
        else if (curr_regime == TEST_PASS)
        {
        //test pass
@@ -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,
+                          SWAP_OPERATORS };

    if ((countOfTransform == 0 || internalExit > 0) && applyFor.find(curr_regime) != applyFor.end())
    {
@@ -1914,13 +1918,6 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
        calculateStatsForPredictor(allFuncInfo, gCovInfo);
        parseDvmDirForPredictor(declaredArrays, commonBlocks, allFuncInfo, gCovInfo);
    }
-    else if (curr_regime == TRANSFORM_ASSUMED_SIZE_PARAMETERS)
-        transformAssumedSizeParameters(allFuncInfo);
-    else if (curr_regime == FIND_PRIVATE_ARRAYS_ANALYSIS)
-        FindPrivateArrays(loopGraph, fullIR, insertedPrivates);
-
-    else if (curr_regime == ARRAY_PROPAGATION)
-        ArrayConstantPropagation(project);

    const float elapsed = duration_cast<milliseconds>(high_resolution_clock::now() - timeForPass).count() / 1000.;
    const float elapsedGlobal = duration_cast<milliseconds>(high_resolution_clock::now() - globalTime).count() / 1000.;
@@ -2156,8 +2153,6 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
        runAnalysis(*project, REMOVE_COPIES, false);
        runAnalysis(*project, SWAP_LOOPS, false);

-        runPass(TRANSFORM_ASSUMED_SIZE_PARAMETERS, proj_name, folderName);
-
        if (folderName || consoleMode)
            runAnalysis(*project, UNPARSE_FILE, true, additionalName.c_str(), folderName);
    }
@@ -2339,6 +2334,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 SWAP_OPERATORS:
        runAnalysis(*project, curr_regime, true, "", folderName);
        break;
    case INLINE_PROCEDURES:
@@ -2378,7 +2374,6 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
    case SUBST_EXPR_RD_AND_UNPARSE:
    case SUBST_EXPR_AND_UNPARSE:
    case REMOVE_DEAD_CODE_AND_UNPARSE:
-    case FIND_PRIVATE_ARRAYS:
        if (folderName)
            runAnalysis(*project, UNPARSE_FILE, true, "", folderName);
        else
@@ -2640,7 +2635,7 @@ int main(int argc, char **argv)
            }
        }

-        if (curr_regime == INSERT_PARALLEL_DIRS_NODIST || curr_regime == FIND_PRIVATE_ARRAYS)
+        if (curr_regime == INSERT_PARALLEL_DIRS_NODIST)
        {
            ignoreArrayDistributeState = true;
            sharedMemoryParallelization = 1;
--- a/src/Sapfor.h
+++ b/src/Sapfor.h
@@ -122,6 +122,8 @@ enum passes {
    CREATE_INTER_TREE,
    INSERT_INTER_TREE,

+    SWAP_OPERATORS,
+
    SHADOW_GROUPING,
    INLINE_PROCEDURES,
    FILL_PARALLEL_REG_IR,
@@ -183,12 +185,8 @@ enum passes {
    SET_IMPLICIT_NONE,
    RENAME_INLCUDES,

-    FIND_PRIVATE_ARRAYS_ANALYSIS,
    FIND_PRIVATE_ARRAYS,

-    TRANSFORM_ASSUMED_SIZE_PARAMETERS,
-    ARRAY_PROPAGATION,
-
    TEST_PASS,
    EMPTY_PASS
 };
@@ -321,6 +319,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[SWAP_OPERATORS] = "SWAP_OPERATORS";
    passNames[CREATE_PARALLEL_REGIONS] = "CREATE_PARALLEL_REGIONS";
    passNames[PRIVATE_REMOVING_ANALYSIS] = "PRIVATE_REMOVING_ANALYSIS";
    passNames[PRIVATE_REMOVING] = "PRIVATE_REMOVING";
@@ -373,12 +372,8 @@ static void setPassValues()
    passNames[SET_IMPLICIT_NONE] = "SET_IMPLICIT_NONE";
    passNames[RENAME_INLCUDES] = "RENAME_INLCUDES";
    passNames[INSERT_NO_DISTR_FLAGS_FROM_GUI] = "INSERT_NO_DISTR_FLAGS_FROM_GUI";
-    passNames[FIND_PRIVATE_ARRAYS_ANALYSIS] = "FIND_PRIVATE_ARRAYS_ANALYSIS";
    passNames[FIND_PRIVATE_ARRAYS] = "FIND_PRIVATE_ARRAYS";

-    passNames[TRANSFORM_ASSUMED_SIZE_PARAMETERS] = "TRANSFORM_ASSUMED_SIZE_PARAMETERS";
-    passNames[ARRAY_PROPAGATION] = "ARRAY_PROPAGATION";
-
    passNames[TEST_PASS] = "TEST_PASS";
 }

--- a/src/SapforData.h
+++ b/src/SapforData.h
@@ -175,11 +175,6 @@ std::set<std::tuple<std::string, int, std::string>> parametersOfProject; // [fil
 //for GET_MIN_MAX_BLOCK_DIST
 std::pair<int, int> min_max_block = std::make_pair(-1, -1);
 //
-
-//for FIND_PRIVATE_ARRAYS
-std::set<SgStatement*> insertedPrivates;
-//
-
 const char* passNames[EMPTY_PASS + 1];
 const char* optionNames[EMPTY_OPTION + 1];
 bool passNamesWasInit = false;
--- a/src/Transformations/DeadCodeRemoving/dead_code.cpp
+++ b/src/Transformations/DeadCodeRemoving/dead_code.cpp
@@ -6,7 +6,7 @@
 #include <set>
 #include <algorithm>

-#include "../CFGraph/CFGraph.h"
+#include "../../CFGraph/CFGraph.h"

 using std::map;
 using std::string;
--- a/src/Transformations/DeadCodeRemoving/dead_code.h
+++ b/src/Transformations/DeadCodeRemoving/dead_code.h
@@ -4,10 +4,10 @@
 #include<vector>

 #include "SgUtils.h"
-#include "CFGraph/CFGraph.h"
-#include "CFGraph/live_variable_analysis.h"
-#include "CFGraph/DataFlow/data_flow.h"
-#include "CFGraph/DataFlow/backward_data_flow.h"
+#include "../CFGraph/CFGraph.h"
+#include "../CFGraph/live_variable_analysis.h"
+#include "../CFGraph/DataFlow/data_flow.h"
+#include "../CFGraph/DataFlow/backward_data_flow.h"

 int removeDeadCode(SgStatement* func, 
                   const std::map<std::string, std::vector<FuncInfo*>>&allFuncs,
--- a/src/Transformations/ExpressionSubstitution/expr_transform.cpp
+++ b/src/Transformations/ExpressionSubstitution/expr_transform.cpp
@@ -440,18 +440,15 @@ bool replaceConstantRec(SgExpression *&exp)
    if (exp->variant() == CONST_REF)
    {
        SgExpression *ret = ReplaceParameter_(exp);
-
        int sign = 1;
        SgExpression* toCalc = ret;
-        if (toCalc->variant() == UNARY_ADD_OP)
-            toCalc = toCalc->lhs();
-
-        if (toCalc->variant() == MINUS_OP)
+        if (ret->variant() == UNARY_ADD_OP)
+            toCalc = ret->lhs();
+        if (ret->variant() == MINUS_OP)
        {
-            toCalc = toCalc->lhs();
+            toCalc = ret->lhs();
            sign = -1;
        }
-
        if (toCalc->isInteger())
        {
            exp = new SgValueExp(sign * toCalc->valueInteger());
--- a/src/Transformations/FunctionPurifying/function_purifying.cpp
+++ b/src/Transformations/FunctionPurifying/function_purifying.cpp
@@ -66,7 +66,7 @@ void insertIntrinsicStat(const vector<FuncInfo*>& allFuncInfo)

            void* ptr = call.pointerDetailCallsFrom.first;
            int var = call.pointerDetailCallsFrom.second;
-
+            
            SgSymbol* s = NULL;
            if (var == PROC_STAT)
                s = ((SgStatement*)ptr)->symbol();
@@ -103,7 +103,7 @@ void insertIntrinsicStat(const vector<FuncInfo*>& allFuncInfo)
            if (line <= 0)
                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);

-            intr->setlineNumber(getNextNegativeLineNumber());
+            intr->setlineNumber(line);
            st->insertStmtBefore(*intr, *func->funcPointer);
        }
        else
@@ -126,7 +126,7 @@ bool checkOutCalls(const set<string>& outCalls)
    return false;
 }

-void createInterfacesForOutCalls(FuncInfo* func)
+void createInterfacesForOutCalls(FuncInfo* func) 
 {
    if (func->isPure && !func->isMain)
    {
@@ -136,41 +136,33 @@ void createInterfacesForOutCalls(FuncInfo* func)
    }
 }

-static bool changeIfHasStarRange(SgExpression* arrayDecl, SgStatement* scope, vector<SgSymbol*>& parNames)
+static bool changeIfHasStarRange(SgExpression* arrayDecl, bool doReplace = false)
 {
    SgExpression* list = arrayDecl->lhs();
-    string varN = arrayDecl->symbol()->identifier() + string("_sz");
-    bool has = false;
-
-    SgExpression* allDimsBefore = NULL;
+    bool has = doReplace;
+    
    while (list)
    {
        const int var = list->lhs()->variant();
        if (var == STAR_RANGE)
-        {
            has = true;
-
-            parNames.push_back(new SgSymbol(VARIABLE_NAME, varN.c_str(), SgTypeInt(), scope));
-            SgExpression* par = allDimsBefore ? &(*new SgVarRefExp(parNames.back()) / *allDimsBefore) : (new SgVarRefExp(parNames.back()));
-
-            list->setLhs(par);
-            break;
-        }
-        else
-        {
-            if (allDimsBefore == NULL)
-                allDimsBefore = list->lhs();
-            else
-                allDimsBefore = &(*allDimsBefore * *list->lhs()->copyPtr());
-        }
-
        list = list->rhs();
    }

+    if (has)
+    {
+        list = arrayDecl->lhs();
+        while (list)
+        {
+            list->setLhs(new SgExpression(DDOT));
+            list = list->rhs();
+        }
+    }
+
    return has;
 }

-/*static void removeExternalStat(SgStatement* func, const set<string>& addedInterfaceFor)
+static void removeExternalStat(SgStatement* func, const set<string>& addedInterfaceFor)
 {
    vector<SgStatement*> toRem;
    for (auto st = func; st != func->lastNodeOfStmt(); st = st->lexNext())
@@ -205,7 +197,7 @@ static bool changeIfHasStarRange(SgExpression* arrayDecl, SgStatement* scope, ve

    for (auto& rem : toRem)
        rem->deleteStmt();
-}*/
+}

 template<typename T>
 static vector<FuncInfo*> sortByName(const T &funcs)
@@ -218,25 +210,10 @@ static vector<FuncInfo*> sortByName(const T &funcs)
    return funcList;
 }

-static bool hasDvmParallel(SgStatement *func)
+//XXX: incorrect!!
+/*void createInterfacesForAssumedSize(const map<string, vector<FuncInfo*>>& allFuncInfo)
 {
-    for (auto st = func; st != func->lastNodeOfStmt(); st = st->lexNext())
-    {
-        const int var = st->variant();
-        if (var == DVM_PARALLEL_ON_DIR || var == ACC_REGION_DIR ||
-            var == ACC_ACTUAL_DIR || var == ACC_GET_ACTUAL_DIR)
-            return true;
-
-        if (st->variant() == CONTAINS_STMT)
-            break;
-    }
-
-    return false;
-}
-
-void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFuncInfo)
-{
-    map<string, vector<int>> assumedSizeArraysByFunc;
+    set<FuncInfo*> hasAssumedSizeArrays;

    for (auto& funcByFile : allFuncInfo)
    {
@@ -244,17 +221,11 @@ void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFun
            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);

        for (auto& func : funcByFile.second)
-        {
+        {            
            SgProgHedrStmt* prog = isSgProgHedrStmt(func->funcPointer->GetOriginal());
            if (prog == NULL)
                continue;

-            if (!hasDvmParallel(prog))
-                continue;
-
-            vector<SgSymbol*> parNames;
-            SgStatement* scope = prog->getScopeForDeclare();
-
            vector<SgExpression*> arrayRefs;
            bool hasRefs = false;
            for (int z = 0; z < func->funcParams.countOfPars; ++z)
@@ -274,8 +245,13 @@ void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFun
                        {
                            if (list->lhs() && list->lhs()->symbol()->identifier() == name)
                            {
-                                if (changeIfHasStarRange(list->lhs(), scope, parNames))
-                                    assumedSizeArraysByFunc[func->funcName].push_back(z);
+                                if (changeIfHasStarRange(list->lhs()))
+                                {
+                                    hasRefs = true;
+                                    hasAssumedSizeArrays.insert(func);
+                                }
+                                else
+                                    arrayRefs.push_back(list->lhs());
                                break;
                            }
                            list = list->rhs();
@@ -284,20 +260,13 @@ void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFun
                }
            }

-            if (parNames.size())
-            {
-                SgProcHedrStmt* proc = isSgProcHedrStmt(func->funcPointer->GetOriginal());
-                checkNull(proc, convertFileName(__FILE__).c_str(), __LINE__);
-
-                //makeDeclaration(parNames, scope);
-
-                for (auto& newPar : parNames)
-                    proc->AddArg(*new SgVarRefExp(newPar));
-            }
+            if (hasRefs)
+                for (auto& ref : arrayRefs)
+                    changeIfHasStarRange(ref, true);
        }
    }

-    if (assumedSizeArraysByFunc.size() == 0)
+    if (hasAssumedSizeArrays.size() == 0)
        return;

    for (auto& funcByFile : allFuncInfo)
@@ -305,63 +274,29 @@ void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFun
        if (SgFile::switchToFile(funcByFile.first) == -1)
            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);

-        SgSymbol* funcSize = new SgSymbol(FUNCTION_NAME, "size");
-
        for (auto& func : sortByName(funcByFile.second))
        {
            SgProgHedrStmt* prog = isSgProgHedrStmt(func->funcPointer->GetOriginal());
            if (prog == NULL)
                continue;

-            for (auto& detailedCall : func->callsFromDetailed)
+            set<string> addedInterfaceFor;
+            for (auto& elem : sortByName(func->callsFromV))
            {
-                auto it = assumedSizeArraysByFunc.find(detailedCall.detailCallsFrom.first);
-                if (it != assumedSizeArraysByFunc.end())
+                auto it = hasAssumedSizeArrays.find(elem);
+                if (it != hasAssumedSizeArrays.end())
                {
-                    auto pointer = detailedCall.pointerDetailCallsFrom;
-
-                    SgExpression* list = NULL;
-                    if (pointer.second == FUNC_CALL)
-                    {
-                        SgExpression* p = (SgExpression*)pointer.first;
-                        list = p->lhs();
-                    }
-                    else
-                    {
-                        SgStatement* p = (SgStatement*)pointer.first;
-                        list = p->expr(0);
-                    }
-
-                    SgExpression* last = list;
-                    vector<SgExpression*> pars;
-                    while (list)
-                    {
-                        last = list;
-                        pars.push_back(list->lhs());
-                        list = list->rhs();
-                    }
-
-                    for (int z = 0; z < it->second.size(); ++z)
-                    {
-                        int parNum = it->second[z];
-                        if (parNum >= pars.size())
-                            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-                        //TODO: need to do it better
-                        SgExpression* parArray = pars[parNum]->copyPtr();
-                        parArray->setLhs(NULL);
-                        parArray->setRhs(NULL);
-
-                        SgFunctionCallExp* call = new SgFunctionCallExp(*funcSize, *parArray);
-
-                        last->setRhs(new SgExpression(EXPR_LIST, call));
-                        last = last->rhs();
-                    }
+                    auto callFrom = *it;
+                    DvmhRegionInserter::createInterfaceBlockForOutCall(func, callFrom);
+                    addedInterfaceFor.insert(callFrom->funcName);
                }
            }
-        }
+
+            if (addedInterfaceFor.size())
+                removeExternalStat(prog, addedInterfaceFor);
+        }       
    }
-}
+}*/

 static void setPureStatus(FuncInfo* func)
 {
@@ -379,7 +314,7 @@ static void setPureStatus(FuncInfo* func)
        bool hasIO = func->linesOfIO.size() || func->linesOfStop.size();

        if (!hasPure && !hasIO && ((isFunc == false) || (isFunc && hasOut == false)))
-        {
+        {            
            header->setExpression(2, new SgExpression(PURE_OP));
            header->symbol()->setAttribute(header->symbol()->attributes() | PURE_BIT);
        }
@@ -525,7 +460,7 @@ static void insertIntents(set<string>& identificators, SgStatement* header, cons
    if (args.size())
    {
        SgIntentStmt* intent = new SgIntentStmt(*makeExprList(args), *attr);
-        intent->setlineNumber(getNextNegativeLineNumber());
+        intent->setlineNumber(lastDecl->lineNumber());

        lastDecl->insertStmtAfter(*intent, (header == lastDecl) ? *header : *lastDecl->controlParent());
    }
@@ -593,7 +528,7 @@ static void intentInsert(const FuncInfo* func, SgStatement* headerSt)
            OutIdentificators.insert(ident);
    }

-    //remove conflicted intents
+    //remove conflicted intents 
    for (auto& entry : func->entry)
    {
        for (int i = 0; i < entry->funcParams.countOfPars; i++)
@@ -624,11 +559,11 @@ static void intentInsert(const FuncInfo* func, SgStatement* headerSt)
    }

    insertIntents(InOutIdentificators, headerSt, parSym, INOUT_OP, INOUT_BIT);
-    insertIntents(InIdentificators, headerSt, parSym, IN_OP, IN_BIT);
+    insertIntents(InIdentificators, headerSt, parSym, IN_OP, IN_BIT);    
    insertIntents(OutIdentificators, headerSt, parSym, OUT_OP, OUT_BIT);
 }

-void intentInsert(const vector<FuncInfo*>& allFuncInfo)
+void intentInsert(const vector<FuncInfo*>& allFuncInfo) 
 {
    for (auto& func : allFuncInfo)
    {
@@ -697,7 +632,7 @@ static void collectForChange(set<FuncInfo*>& allForChange, FuncInfo* start)
            for (auto& call : elem->callsFromV)
                if (allForChange.find(call) == allForChange.end())
                    newAdd.insert(call);
-
+        
        chagned = newAdd.size() != 0;

        allForChange.insert(newAdd.begin(), newAdd.end());
@@ -705,7 +640,7 @@ static void collectForChange(set<FuncInfo*>& allForChange, FuncInfo* start)
 }

 template<typename CallExp>
-static void transferVarToArg(const map<string, vector<int>>& commonVarsUsed, const map<string, CommonBlock*>& commonBlocks,
+static void transferVarToArg(const map<string, vector<int>>& commonVarsUsed, const map<string, CommonBlock*>& commonBlocks, 
                             const FuncInfo* curFunc, CallExp* callExp)
 {
    for (auto& common : commonVarsUsed)
@@ -789,7 +724,7 @@ static void transferCommons(set<FuncInfo*>& allForChange, map <FuncInfo*, map<st
            {
                SgFunctionCallExp* callExp = (SgFunctionCallExp*)call.first;
                if (callExp->funName()->identifier() == precFunc->funcName)
-                    transferVarToArg(commonVarsUsed, commonBlocks, curFunc, callExp);
+                    transferVarToArg(commonVarsUsed, commonBlocks, curFunc, callExp);                
            }
            else if (isSgProcHedrStmt(precFunc->funcPointer->GetOriginal()) && call.second == PROC_STAT)
            {
@@ -814,7 +749,7 @@ static void transferCommons(set<FuncInfo*>& allForChange, map <FuncInfo*, map<st
                if (v == var)
                    done = true;

-            if (!done)
+            if (!done) 
            {
                funcCommons[curFunc][common.first].push_back(var);
                if (nextCommonVarsUsed.count(common.first) == 0)
@@ -832,7 +767,7 @@ static void transferCommons(set<FuncInfo*>& allForChange, map <FuncInfo*, map<st
    {
        bool uses = false;
        auto groupedVars = commonBlocks.find(common.first)->second->getGroupedVars();
-
+        
        if (curFunc->commonBlocks.count(common.first) > 0) //rename common vars in funcs
        {
            uses = true;
@@ -864,7 +799,7 @@ static void transferCommons(set<FuncInfo*>& allForChange, map <FuncInfo*, map<st
                    }
                }
            }
-        }
+        }        
        else if (!allForChange.count(curFunc)) //add of commons to main
        {
            SgExprListExp* res = NULL;
@@ -1027,13 +962,13 @@ void commonTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo, const map

            if (func->commonBlocks.size() > 0 && st->variant() != PROG_HEDR)
            {
-                for (SgStatement* start = st, *end = st->lastNodeOfStmt(); start != end;)
+                for (SgStatement* start = st, *end = st->lastNodeOfStmt(); start != end;) 
                {
                    if (start->variant() == CONTAINS_STMT)
                        break;

                    SgStatement* next = start->lexNext();
-                    if (start->variant() == COMM_STAT && string(start->fileName()) == func->fileName)
+                    if (start->variant() == COMM_STAT && string(start->fileName()) == func->fileName) 
                    {
                        if (funcCommonDeclared.count(func) == 0)
                            funcCommonDeclared[func] = set<string>();
@@ -1064,11 +999,11 @@ void commonTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo, const map
        if (st->variant() < 0 || st->variant() == PROG_HEDR || func->isInterface)
            continue;

-        if (func->commonBlocks.size() > 0)
+        if (func->commonBlocks.size() > 0) 
        {
            map<string, vector<int>> commonVarsUsed;
            set<string> usedVars;
-            for (SgStatement* start = st->lastDeclaration()->lexNext(), *end = st->lastNodeOfStmt(); start != end; start = start->lexNext())
+            for (SgStatement* start = st->lastDeclaration()->lexNext(), *end = st->lastNodeOfStmt(); start != end; start = start->lexNext()) 
            {
                if (start->variant() == CONTAINS_STMT)
                    break;
@@ -1138,7 +1073,7 @@ static string changeData(const string& data, const map<string, string>& constSym
    return res;
 }

-static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vector <SgSymbol*>& varsToTransfer, vector <string>& dataToTransfer,
+static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vector <SgSymbol*>& varsToTransfer, vector <string>& dataToTransfer, 
                         FuncInfo* curFunc, FuncInfo* precFunc, FuncInfo* startFunc)
 {
    if (curFunc != precFunc)
@@ -1159,7 +1094,7 @@ static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vec
            else if (isSgProcHedrStmt(precFunc->funcPointer->GetOriginal()) && call.second == PROC_STAT)
            {
                SgCallStmt* callSt = (SgCallStmt*)call.first;
-                if (callSt->name()->identifier() == precFunc->funcName)
+                if (callSt->name()->identifier() == precFunc->funcName)                
                    for (auto& var : varsToTransfer)
                        callSt->addArg(*new SgVarRefExp(*var));
            }
@@ -1185,7 +1120,7 @@ static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vec
            {
                ((SgProcHedrStmt*)(hedr))->AddArg(*new SgVarRefExp(var->copy()));
                hedr->lexNext()->deleteStmt();
-                if (curFunc != startFunc || i!=0)
+                if (curFunc != startFunc || i!=0) 
                {
                    vector<SgSymbol*> varVec = vector<SgSymbol*>();
                    varVec.push_back(var);
@@ -1225,7 +1160,7 @@ static void transferSave(map<FuncInfo*, set<FuncInfo*>>& funcAddedVarsFuncs, vec

        for (SgStatement* start = hedr->lexNext(), *end = hedr->lastNodeOfStmt(); start != end; start = start->lexNext())
        {
-            if ((isSgExecutableStatement(start) || isSgDeclarationStatement(start)) && !strcmp(hedr->fileName(), start->fileName()))
+            if ((isSgExecutableStatement(start) || isSgDeclarationStatement(start)) && !strcmp(hedr->fileName(), start->fileName())) 
            {
                firstExDec = start;
                break;
@@ -1264,7 +1199,7 @@ void saveTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
    for (auto& byfile : allFuncInfo)
        for (auto& func : byfile.second)
            if (func->isMain)
-                start = func;
+                start = func;    

    collectForChange(allForChange, start);
    allForChange.erase(start);
@@ -1306,8 +1241,8 @@ void saveTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)

            if (s->scope() == st)
            {
-                if ( (s->attributes() & SAVE_BIT) ||
-                     (s->attributes() & DATA_BIT) ||
+                if ( (s->attributes() & SAVE_BIT) || 
+                     (s->attributes() & DATA_BIT) || 
                     allSave && s->variant() == VARIABLE_NAME && !params.count(s->identifier()))
                {
                    if ((s->type() ? s->type()->variant() : (T_COMPLEX + 1)) > T_COMPLEX)
@@ -1358,21 +1293,21 @@ void saveTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)

                SgExprListExp* attrsNoSave = new SgExprListExp();
                bool needChange = false;
-                for (int i = 0; i < vst->numberOfAttributes(); i++)
+                for (int i = 0; i < vst->numberOfAttributes(); i++) 
                {
                    if (vst->attribute(i)->variant() != SAVE_OP)
                    {
                        attrsNoSave->append(vst->attribute(i)->copy());
-                    }
+                    } 
                    else
-                        needChange = true;
+                        needChange = true;                    
                }

-                if (needChange)
+                if (needChange) 
                {
                    SgVarDeclStmt* newVst;
                    if (!attrsNoSave->length())
-                        newVst = new SgVarDeclStmt(vst->varList()->copy(), *attrsNoSave, vst->type()->copy());
+                        newVst = new SgVarDeclStmt(vst->varList()->copy(), *attrsNoSave, vst->type()->copy());                    
                    else
                        newVst = new SgVarDeclStmt(vst->varList()->copy(), vst->type()->copy());

@@ -1400,8 +1335,8 @@ void saveTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
    }
 }*/

-static string makeName(SgSymbol* var, map<SgSymbol*, set< SgSymbol*>>& modVarsToAdd, const set<string>& useMod,
-                       const map<string, vector<pair<SgSymbol*, SgSymbol*>>>& modByUse,
+static string makeName(SgSymbol* var, map<SgSymbol*, set< SgSymbol*>>& modVarsToAdd, const set<string>& useMod, 
+                       const map<string, vector<pair<SgSymbol*, SgSymbol*>>>& modByUse, 
                       const map<string, vector<pair<SgSymbol*, SgSymbol*>>>& modByUseOnly)
 {
    string name = "", modName = OriginalSymbol(var)->scope()->symbol()->identifier();
@@ -1423,7 +1358,7 @@ static string makeName(SgSymbol* var, map<SgSymbol*, set< SgSymbol*>>& modVarsTo
        }

        if (!name.length())
-            name = varOrName;
+            name = varOrName;        
    }
    else if (mbuo)
    {
@@ -1557,7 +1492,7 @@ static string getInterfaceBlock(SgStatement* func, const FuncParam& pars)
        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);

    //insert tabs
-    const string tab = "    ";
+    const string tab = "    ";    
    const int countEnds = std::count(codeString.begin(), codeString.end(), '\n');

    string retVal = "  ";
@@ -1649,7 +1584,7 @@ static void createInterfaceBlockForToCalls(FuncInfo* func)
    }
 }

-static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, set<FuncInfo*>& allForChange,
+static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, set<FuncInfo*>& allForChange, 
                           vector<SgSymbol*>& varsToTransfer, FuncInfo* curFunc, FuncInfo* precFunc, set<FuncInfo*>& funcForInterfaceAdd)
 {
    SgStatement* st = curFunc->funcPointer->GetOriginal();
@@ -1701,7 +1636,7 @@ static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, se
            else if (isSgProcHedrStmt(precFunc->funcPointer->GetOriginal()) && call.second == PROC_STAT)
            {
                SgCallStmt* callSt = (SgCallStmt*)call.first;
-                if (callSt->name()->identifier() == precFunc->funcName)
+                if (callSt->name()->identifier() == precFunc->funcName) 
                {
                    for (auto& var : varsToTransfer)
                    {
@@ -1753,7 +1688,7 @@ static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, se
            {
                if (i == 0)
                    curFunc->funcParams.identificators.push_back(var->identifier());
-
+     
                ((SgProcHedrStmt*)(hedr))->AddArg(*new SgVarRefExp(var->copy()));
                hedr->lexNext()->deleteStmt();
                vector<SgSymbol*> varVec = vector<SgSymbol*>();
@@ -1777,7 +1712,7 @@ static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, se
                        }
                    }

-                    if (!isAuto)
+                    if (!isAuto) 
                    {
                        funcForInterfaceAdd.insert(curFunc);
                        SgAttributeExp* a = new SgAttributeExp(ALLOCATABLE_OP);
@@ -1797,8 +1732,8 @@ static void transferModule(map<FuncInfo*, set<SgSymbol*>>& funcAddedVarsMods, se
                SgStatement* firstExDec = NULL;
                for (SgStatement* start = hedr->lexNext(), *end = hedr->lastNodeOfStmt(); start != end; start = start->lexNext())
                {
-                    if ((isSgExecutableStatement(start) || isSgDeclarationStatement(start)) &&
-                        !strcmp(hedr->fileName(), start->fileName()))
+                    if ((isSgExecutableStatement(start) || isSgDeclarationStatement(start)) && 
+                        !strcmp(hedr->fileName(), start->fileName())) 
                    {
                        firstExDec = start;
                        break;
@@ -1889,7 +1824,7 @@ void moduleTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
                break;

            SgStatement* next = start->lexNext();
-            if (start->variant() == USE_STMT)
+            if (start->variant() == USE_STMT) 
            {
                SgExpression* onlyE = start->expr(0);
                if (onlyE)
@@ -1915,7 +1850,7 @@ void moduleTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
                    }

                    if (renameL)
-                        onlyE->setLhs(renameL);
+                        onlyE->setLhs(renameL);                    
                    else
                        start->deleteStmt();
                }
@@ -1923,7 +1858,7 @@ void moduleTransfer(const map<string, vector<FuncInfo*>>& allFuncInfo)
            if (isSgExecutableStatement(start)|| isSgDeclarationStatement(start))
                for (int i = 0; i < 3; i++)
                    fillUsedVars(usedVars, start->expr(i));
-
+            
          //  if (start->variant() == IMPL_DECL)
            //    start->deleteStmt();
            start = next;
--- a/src/Transformations/FunctionPurifying/function_purifying.h
+++ b/src/Transformations/FunctionPurifying/function_purifying.h
@@ -14,6 +14,4 @@ void commonTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFunc
 void saveTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
 void moduleTransfer(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);

-void insertInterface(SgStatement* func, const FuncInfo* callFrom);
-
-void transformAssumedSizeParameters(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo);
+void insertInterface(SgStatement* func, const FuncInfo* callFrom);
--- a/src/Transformations/LoopCombining/loops_combiner.cpp
+++ b/src/Transformations/LoopCombining/loops_combiner.cpp
@@ -1123,7 +1123,7 @@ static bool hasDependenciesBetweenArrays(LoopGraph* firstLoop, LoopGraph* loop,
        for (int d = 0; d < dimensions; ++d)
        {
            //по измерениям массива отображение на цикл вложенности d
-            vector<set<pair<int, int>>> coeffsRead[2], coeffsWrite[2];
+            vector<set<pair<int, int>>> coefsRead[2], coefsWrite[2];

            checkNull(currLoop[0], convertFileName(__FILE__).c_str(), __LINE__);
            checkNull(currLoop[1], convertFileName(__FILE__).c_str(), __LINE__);
@@ -1133,31 +1133,31 @@ static bool hasDependenciesBetweenArrays(LoopGraph* firstLoop, LoopGraph* loop,
                auto it = currLoop[k]->readOpsForLoop.find(array);
                if (it != currLoop[k]->readOpsForLoop.end())
                {
-                    if (coeffsRead[k].size() == 0)
-                        coeffsRead[k].resize(it->second.size());
+                    if (coefsRead[k].size() == 0)
+                        coefsRead[k].resize(it->second.size());

                    for (int z = 0; z < it->second.size(); ++z)
                        if (it->second[z].coefficients.size())
                            for (auto& coef : it->second[z].coefficients)
-                                coeffsRead[k][z].insert(coef.first);
+                                coefsRead[k][z].insert(coef.first);
                }

                auto itW = currLoop[k]->writeOpsForLoop.find(array);
                if (itW != currLoop[k]->writeOpsForLoop.end())
                {
-                    if (coeffsWrite[k].size() == 0)
-                        coeffsWrite[k].resize(itW->second.size());
+                    if (coefsWrite[k].size() == 0)
+                        coefsWrite[k].resize(itW->second.size());

                    for (int z = 0; z < itW->second.size(); ++z)
                        if (itW->second[z].coefficients.size())
                            for (auto& coef : itW->second[z].coefficients)
-                                coeffsWrite[k][z].insert(coef.first);
+                                coefsWrite[k][z].insert(coef.first);
                }
            }

            //нет записей, значит нет зависимости
            bool nulWrite = true;
-            for (auto& wr : coeffsWrite)
+            for (auto& wr : coefsWrite)
                for (auto& elem : wr)
                    if (elem.size() != 0)
                        nulWrite = false;
@@ -1168,62 +1168,62 @@ static bool hasDependenciesBetweenArrays(LoopGraph* firstLoop, LoopGraph* loop,
            // если чтение в одном цикле и запись (и наоборот) в другом идут по разным правилам, то пока что это зависимость.
            // здесь можно уточнить.

-            const int len = std::max(coeffsWrite[0].size(), coeffsRead[0].size());
+            const int len = std::max(coefsWrite[0].size(), coefsRead[0].size());
            int countW[2] = { 0, 0 };
            int countR[2] = { 0, 0 };

            for (int L = 0; L < 2; ++L)
-                for (int z = 0; z < coeffsWrite[L].size(); ++z)
-                    countW[L] += (coeffsWrite[L][z].size() ? 1 : 0);
+                for (int z = 0; z < coefsWrite[L].size(); ++z)
+                    countW[L] += (coefsWrite[L][z].size() ? 1 : 0);

            for (int L = 0; L < 2; ++L)
-                for (int z = 0; z < coeffsRead[L].size(); ++z)
-                    countR[L] += (coeffsRead[L][z].size() ? 1 : 0);
+                for (int z = 0; z < coefsRead[L].size(); ++z)
+                    countR[L] += (coefsRead[L][z].size() ? 1 : 0);

            for (int p = 0; p < len; ++p)
            {
-                if (coeffsWrite[1].size() && coeffsWrite[0].size())
-                    if (coeffsWrite[0][p].size() != 0 && coeffsWrite[1][p].size() != 0)
-                        if (coeffsWrite[0][p] != coeffsWrite[1][p])
+                if (coefsWrite[1].size() && coefsWrite[0].size())
+                    if (coefsWrite[0][p].size() != 0 && coefsWrite[1][p].size() != 0)
+                        if (coefsWrite[0][p] != coefsWrite[1][p])
                            return true;

-                if (coeffsRead[1].size() && coeffsWrite[0].size())
-                    if (coeffsWrite[0][p].size() != 0 && coeffsRead[1][p].size() != 0)
-                        if (coeffsWrite[0][p] != coeffsRead[1][p])
+                if (coefsRead[1].size() && coefsWrite[0].size())
+                    if (coefsWrite[0][p].size() != 0 && coefsRead[1][p].size() != 0)
+                        if (coefsWrite[0][p] != coefsRead[1][p])
                            return true;

-                if (coeffsWrite[1].size() && coeffsRead[0].size())
-                    if (coeffsWrite[1][p].size() != 0 && coeffsRead[0][p].size() != 0)
-                        if (coeffsWrite[1][p] != coeffsRead[0][p])
+                if (coefsWrite[1].size() && coefsRead[0].size())
+                    if (coefsWrite[1][p].size() != 0 && coefsRead[0][p].size() != 0)
+                        if (coefsWrite[1][p] != coefsRead[0][p])
                            return true;
                

                //отображение на разные измерения
-                if (coeffsWrite[1].size() && coeffsWrite[0].size())
+                if (coefsWrite[1].size() && coefsWrite[0].size())
                {
-                    if (coeffsWrite[0][p].size() != 0 && coeffsWrite[1][p].size() == 0 && countW[1] ||
-                        coeffsWrite[0][p].size() == 0 && coeffsWrite[1][p].size() != 0 && countW[0])
+                    if (coefsWrite[0][p].size() != 0 && coefsWrite[1][p].size() == 0 && countW[1] ||
+                        coefsWrite[0][p].size() == 0 && coefsWrite[1][p].size() != 0 && countW[0])
                        return true;
                }

-                if (coeffsRead[1].size() && coeffsWrite[0].size())
+                if (coefsRead[1].size() && coefsWrite[0].size())
                {
-                    if (coeffsWrite[0][p].size() != 0 && coeffsRead[1][p].size() == 0 && countR[1] ||
-                        coeffsWrite[0][p].size() == 0 && coeffsRead[1][p].size() != 0 && countW[0])
+                    if (coefsWrite[0][p].size() != 0 && coefsRead[1][p].size() == 0 && countR[1] ||
+                        coefsWrite[0][p].size() == 0 && coefsRead[1][p].size() != 0 && countW[0])
                        return true;
                }

-                if (coeffsWrite[1].size() && coeffsRead[1].size())
+                if (coefsWrite[1].size() && coefsRead[1].size())
                {
-                    if (coeffsWrite[1][p].size() != 0 && coeffsRead[0][p].size() == 0 && countR[0] ||
-                        coeffsWrite[1][p].size() == 0 && coeffsRead[0][p].size() != 0 && countW[1])
+                    if (coefsWrite[1][p].size() != 0 && coefsRead[0][p].size() == 0 && countR[0] ||
+                        coefsWrite[1][p].size() == 0 && coefsRead[0][p].size() != 0 && countW[1])
                        return true;
                }

                //где то нет правил отображения вообще, но есть факт его наличия. 
-                if ( ((coeffsWrite[0].size() == 0 && coeffsRead[0].size() == 0) && (countW[0] == 0 && countR[0] == 0)) 
+                if ( ((coefsWrite[0].size() == 0 && coefsRead[0].size() == 0) && (countW[0] == 0 && countR[0] == 0)) 
                    ||
-                    ((coeffsWrite[1].size() == 0 && coeffsRead[1].size() == 0) && (countW[1] == 0 && countR[1] == 0)) )
+                    ((coefsWrite[1].size() == 0 && coefsRead[1].size() == 0) && (countW[1] == 0 && countR[1] == 0)) )
                    return true;
            }
            
--- a/src/Transformations/LoopSplitting/loops_splitter.cpp
+++ b/src/Transformations/LoopSplitting/loops_splitter.cpp
@@ -6,7 +6,7 @@
 #include "../LoopAnalyzer/loop_analyzer.h"
 #include "expr_transform.h"
 #include "errors.h"
-#include "CFGraph/CFGraph.h"
+#include "../CFGraph/CFGraph.h"
 #include "../SageAnalysisTool/OmegaForSage/include/lang-interf.h"
 #include "../DirectiveProcessing/directive_parser.h"
 #include "../DirectiveProcessing/directive_omp_parser.h"
--- a/src/Transformations/PrivateArrayRemoving/private_removing.h
+++ b/src/Transformations/PrivateArrayRemoving/private_removing.h
@@ -2,8 +2,8 @@

 #include "dvm.h"
 #include "../DirectiveProcessing/directive_parser.h"
-#include "CFGraph/CFGraph.h"
-#include "CFGraph/RD_subst.h"
+#include "../CFGraph/CFGraph.h"
+#include "../CFGraph/RD_subst.h"

 // Regime defines the regime of private removing
 enum class Regime { DEFLT = 1, REGULAR_INDEXES };
--- a/src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp
+++ b/src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp
@@ -17,157 +17,6 @@ using std::pair;

 #define DEBUG_TRACE 0

-static bool hasArrayRef(SgExpression* ex)
-{
-    if (ex)
-        return isArrayRef(ex) || hasArrayRef(ex->lhs()) || hasArrayRef(ex->rhs());
-
-    return false;
-}
-
-static inline bool isArrayDeclaration(SgStatement* st)
-{
-    return isSgDeclarationStatement(st) || isSgVarListDeclStmt(st) || isSgNestedVarListDeclStmt(st);
-}
-
-static SgExpression* findExprWithVariant(SgExpression* exp, int variant)
-{
-    if (exp)
-    {
-        if (exp->variant() == variant)
-            return exp;
-
-        auto *l = findExprWithVariant(exp->lhs(), variant);
-        if (l)
-            return l;
-
-        auto *r = findExprWithVariant(exp->rhs(), variant);
-        if (r)
-            return r;
-    }
-
-    return NULL;
-}
-
-static bool switchToDeclarationFile(DIST::Array* array_p, 
-                                    pair<string, int>& decl_place, 
-                                    const string &current_file_name,
-                                    FuncInfo *current_func)
-{
-    if (!array_p)
-        return false;
-
-    // try to find declaration from current function
-    for (const auto &p : array_p->GetDeclInfo())
-    {
-        if (p.first == current_file_name && 
-            current_func->linesNum.first <= p.second && 
-            p.second <= current_func->linesNum.second)
-        {
-            decl_place = p;
-            return true;
-        }
-    }
-
-    for (const auto &p : array_p->GetDeclInfo())
-    {
-        if (SgFile::switchToFile(p.first) != -1)
-        {
-            decl_place = p;
-            return true;
-        }
-    }
-
-    return false;
-}
-
-static bool checkAssumedShape(SgStatement* decl, const string& array_name)
-{
-    SgExpression* list = decl->expr(0);
-    SgExpression* dim_list = NULL;
-
-    while (list)
-    {
-        auto *arr_ref = list->lhs();
-
-        if (arr_ref && 
-            arr_ref->symbol() && 
-            arr_ref->symbol()->identifier() && 
-            arr_ref->symbol()->identifier() == array_name)
-        {
-            dim_list = arr_ref->lhs();
-            break;
-        }
-
-        list = list->rhs();
-    }
-
-    if (!dim_list)
-    {
-        auto *dim_expr = findExprWithVariant(decl->expr(2), DIMENSION_OP);
-        if (dim_expr)
-            dim_list = dim_expr->lhs();
-    }
-
-    while (dim_list)
-    {
-        auto *lhs = dim_list->lhs();
-
-        if (lhs && lhs->variant() == DDOT && (!lhs->lhs() || !lhs->rhs()))
-            return true;
-
-        dim_list = dim_list->rhs();
-    }
-
-    return false;
-}
-
-static bool checkAssumedSize(const string &array_name, DIST::Array* array_p, const string &current_file_name, FuncInfo *current_func)
-{
-    if (!array_p)
-        return true; // raise true to prevent array from copying
-
-    bool found = false;
-
-    pair<string, int> decl_place;
-
-    if (!switchToDeclarationFile(array_p, decl_place, current_file_name, current_func))
-        return true;
-
-    auto *st = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
-    checkNull(st, convertFileName(__FILE__).c_str(), __LINE__);
-    
-    SgExpression* list = st->expr(0);    
-    while (list)
-    {
-        if (list->lhs() && 
-            list->lhs()->symbol() && 
-            list->lhs()->symbol()->identifier() && 
-            list->lhs()->symbol()->identifier() == array_name
-        )
-        {
-            if(findExprWithVariant(list->lhs(), STAR_RANGE))
-                found = true;
-
-            break;
-        }
-
-        list = list->rhs();
-    }
-
-    if (!found)
-    {
-        auto *dim_expr = findExprWithVariant(st->expr(2), DIMENSION_OP);
-        if (dim_expr && findExprWithVariant(dim_expr, STAR_RANGE))
-            found = true;
-    }
-
-    if (SgFile::switchToFile(current_file_name) == -1)
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__); // can't switch back to file with array usage
-
-    return found;
-}
-
 static void findArrays(SgExpression* exp, set<SgSymbol*>& arrays)
 {
    if (exp)
@@ -180,15 +29,12 @@ static void findArrays(SgExpression* exp, set<SgSymbol*>& arrays)
    }
 }

-static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& arrays, 
-                                        SgStatement* stat, 
-                                        const string& current_file_name,
-                                        FuncInfo *current_func)
+static void populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& arrays, SgStatement* stat)
 {
    auto var = stat->variant();

    if (var != READ_STAT && var != PRINT_STAT && var != WRITE_STAT)
-        return false;
+        return;

    // check if such IO allowed in dvm: 
    // list should consist only of single array and format string should be *
@@ -198,26 +44,22 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
    SgExpression* ioList = stat->expr(0);

    if (!ioList)
-        return false;
+        return;

    if (ioList->variant() != EXPR_LIST)
-        return false;
+        return;

    if (ioList->rhs() == NULL)
    {
        SgExpression* arg = ioList->lhs();
        if (!arg)
-            return false;
+            return;

-        if (hasArrayRef(arg))
-        {
-            if (isArrayRef(arg) && arg->lhs())
-                need_replace = true;
-        }
-        else
-        {
-            return false;
-        }
+        if (!isArrayRef(arg))
+            return;
+
+        if (arg->lhs())
+            need_replace = true;
    }
    else
    {
@@ -232,11 +74,15 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
        {
            SgExpression* fmt = stat->expr(1);
            if (!fmt || fmt->variant() != SPEC_PAIR || fmt->lhs()->variant() != KEYWORD_VAL)
+            {
                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                return;
+            }

            if (fmt->rhs()->variant() != KEYWORD_VAL || fmt->rhs()->sunparse() != "*")
                need_replace = true;

+
            break;
        }
        case READ_STAT:
@@ -258,7 +104,10 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
                {
                    auto *kv = spec->lhs();
                    if (!kv || kv->variant() != SPEC_PAIR || !kv->rhs())
+                    {
                        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                        return;
+                    }

                    if (kv->rhs()->variant() != KEYWORD_VAL || kv->rhs()->sunparse() != "*")
                    {
@@ -269,7 +118,6 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
                    spec = spec->rhs();
                }
            }
-            break;
        }
        default:
            break;
@@ -277,9 +125,7 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
    }

    if (!need_replace)
-        return false;
-
-    bool ret = false;
+        return;

    set<SgSymbol*> found_arrays;

@@ -290,21 +136,11 @@ static bool populateDistributedIoArrays(map<SgSymbol*, set<SgStatement*>>& array
    {
        string array_name = string(by_symb->identifier());
        DIST::Array* array_p = getArrayFromDeclarated(declaratedInStmt(by_symb), array_name);
-        if (array_p && 
-            array_p->GetDistributeFlagVal() == Distribution::distFlag::IO_PRIV && 
-            !checkAssumedSize(array_name, array_p, current_file_name, current_func))
-        {
-            auto inserted = arrays[by_symb].insert(stat).second;
-
-            if (inserted)
-                __spf_print(DEBUG_TRACE, "[%d]: add array %s %p\n", stat->lineNumber(), array_p->GetName().c_str(), by_symb);
-
-            ret = true;
-        }
+        if (array_p && array_p->GetDistributeFlagVal() == Distribution::distFlag::IO_PRIV && arrays[by_symb].insert(stat).second)
+            __spf_print(DEBUG_TRACE, "[%d]: add array %s\n", stat->lineNumber(), array_p->GetName().c_str());
    }

    __spf_print(DEBUG_TRACE, "[replace]\n");
-    return ret;
 }

 static void replaceArrayRec(SgSymbol* arr, SgSymbol* replace_by, SgExpression* exp, bool& has_read, bool& has_write, bool from_read, bool from_write)
@@ -374,12 +210,7 @@ static void replaceArrayRec(SgSymbol* arr, SgSymbol* replace_by, SgStatement* st
    }
 }

-static void copyArrayBetweenStatements(SgSymbol* replace_symb, 
-                                       SgSymbol* replace_by,
-                                       SgStatement* start, 
-                                       SgStatement* last, 
-                                       bool start_is_scope,
-                                       FuncInfo *func_info)
+static void copyArrayBetweenStatements(SgSymbol* replace_symb, SgSymbol* replace_by, SgStatement* start, SgStatement* last, bool start_is_scope)
 {
    while (start->lexNext() && !isSgExecutableStatement(start->lexNext()))
        start = start->lexNext();
@@ -398,23 +229,10 @@ static void copyArrayBetweenStatements(SgSymbol* replace_symb,
        auto* parent = start_is_scope ? start : start->controlParent();
        if (parent && parent->lastNodeOfStmt() == start)
            parent = parent->controlParent();
-        checkNull(parent, convertFileName(__FILE__).c_str(), __LINE__);

        start->insertStmtAfter(*assign, *parent);
    }

-    if (has_write)
-    {
-        for (int i = 0; i < func_info->funcParams.identificators.size(); i++)
-        {
-            if (func_info->funcParams.identificators[i] == replace_symb->identifier())
-            {
-                has_write &= func_info->funcParams.isArgOut(i);
-                break;
-            }
-        }
-    }
-
    if (has_write)
    {
        // A = A_reg
@@ -425,14 +243,9 @@ static void copyArrayBetweenStatements(SgSymbol* replace_symb,
    }
 }

-static void replaceArrayInFragment(SgSymbol* replace_symb, 
-                                   const set<SgStatement*> usages, 
-                                   SgSymbol* replace_by, 
-                                   SgStatement* start, 
-                                   SgStatement* last, 
-                                   FuncInfo *func_info)
+static void replaceArrayInFragment(SgSymbol* replace_symb, const set<SgStatement*> usages, SgSymbol* replace_by, SgStatement* start, SgStatement* last, const string& filename)
 {
-    while (start->lexNext() && (!isSgExecutableStatement(start->lexNext()) || start->lexNext()->variant() == ALLOCATE_STMT))
+    while (start->lexNext() && !isSgExecutableStatement(start->lexNext()))
        start = start->lexNext();

    set<SgStatement*> not_opened, not_closed, copied;
@@ -499,7 +312,7 @@ static void replaceArrayInFragment(SgSymbol* replace_symb,
        }

        __spf_print(DEBUG_TRACE, "[copy %s] [%d, %d]\n", replace_symb->identifier(), scope_start->lineNumber(), scope_end->lineNumber());
-        copyArrayBetweenStatements(replace_symb, replace_by, scope_start, scope_end, copy_scope == scope_start, func_info);
+        copyArrayBetweenStatements(replace_symb, replace_by, scope_start, scope_end, copy_scope == scope_start);
        copied.insert(copy_scope);
    }
 }
@@ -522,16 +335,12 @@ static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
        STOP_STAT,
        STOP_NODE,
        EXIT_STMT,
-        EXIT_NODE,
-        GOTO_NODE
+        EXIT_NODE
    };

    if (border_stats.find(var) != border_stats.end())
        return true;

-    if (stat->hasLabel())
-        return true;
-
    if (last_io_bound && last_io_bound->lastNodeOfStmt() && last_io_bound->lastNodeOfStmt() == stat)
        return true;

@@ -544,9 +353,9 @@ static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
 }

 void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
-                                  const map<string, vector<FuncInfo*>>& allFuncInfo,
-                                  map<string, vector<Messages>>& SPF_messages,
-                                  map<string, map<int, set<string>>>& newDeclsToInclude)
+    const map<string, vector<FuncInfo*>>& allFuncInfo,
+    map<string, vector<Messages>>& SPF_messages,
+    map<string, map<int, set<string>>>& newDeclsToInclude)
 {
    map<SgSymbol*, SgSymbol*> created_copies;
    map<string, map<int, set<string>>> copied_syms;
@@ -555,29 +364,26 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
    {
        __spf_print(DEBUG_TRACE, "[%s]: enter region\n", region->GetName().c_str());

-        for (auto& lines_by_file : region->GetAllLinesToModify())
+        for (auto& linesByFile : region->GetAllLinesToModify())
        {
-            const auto& current_file_name = lines_by_file.first;
+            const auto& filename = linesByFile.first;

-            if (SgFile::switchToFile(current_file_name) == -1)
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-            auto func_info_it = allFuncInfo.find(current_file_name);
-            if (func_info_it == allFuncInfo.end())
-                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-            auto *lbound_symb = new SgSymbol(FUNCTION_NAME, "lbound");
-            auto *ubound_symb = new SgSymbol(FUNCTION_NAME, "ubound");
-
-            for (auto& lines : lines_by_file.second)
+            if (SgFile::switchToFile(filename) < 0)
            {
-                __spf_print(DEBUG_TRACE, "[fragment] %s: %d:%d %d\n", current_file_name.c_str(), lines.lines.first,
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                return;
+            }
+
+            for (auto& lines : linesByFile.second)
+            {
+                __spf_print(DEBUG_TRACE, "[fragment] %s: %d:%d %d\n", filename.c_str(), lines.lines.first,
                    lines.lines.second, lines.isImplicit());

                SgStatement* curr_stmt, * end;

                if (lines.isImplicit())
                {
+
                    curr_stmt = current_file->SgStatementAtLine(lines.lines.first);
                    end = current_file->SgStatementAtLine(lines.lines.second);

@@ -593,7 +399,6 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                map<SgSymbol*, set<SgStatement*>> need_replace;
                SgStatement* last_io_bound = NULL;

-                FuncInfo *current_func_info = NULL;

                while (curr_stmt != end)
                {
@@ -602,21 +407,9 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,

                    auto var = curr_stmt->variant();

+
                    if (var == PROC_HEDR || var == PROG_HEDR || var == FUNC_HEDR)
                    {
-                        current_func_info = NULL;
-                        for (auto *func_info : func_info_it->second)
-                        {
-                            if (func_info->funcName == curr_stmt->symbol()->identifier())
-                            {
-                                current_func_info = func_info;
-                                break;
-                            }
-                        }
-
-                        if (!current_func_info)
-                            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
                        curr_stmt = curr_stmt->lexNext();
                        while (curr_stmt && !isSgExecutableStatement(curr_stmt))
                        {
@@ -640,192 +433,77 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                string array_name = string(array_to_copy->identifier());
                                DIST::Array* array_p = getArrayFromDeclarated(declaratedInStmt(array_to_copy), array_name);

-                                // at this point all considered arrays must have DIST::Array* references
-                                if (!array_p)
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-                                // ... and be declared in switchable files (not in headers)
-                                pair<string, int> decl_place;
-                                if (!switchToDeclarationFile(array_p, decl_place, current_file_name, current_func_info))
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                                bool fromModule = (array_p->GetLocation().first == DIST::l_MODULE);
+                                const string locationName = array_p->GetLocation().second;

+                                auto place = *array_p->GetDeclInfo().begin();
+                                string fileName = place.first;
                                string suffix = "_io_l";

-                                switch (array_p->GetLocation().first)
+                                if (fromModule)
+                                    suffix = "_io_m";
+
+                                pair<SgSymbol*, SgSymbol*> copied;
+                                copied.first = array_to_copy;
+
+                                if (SgFile::switchToFile(fileName) == -1)
                                {
-                                    case DIST::l_MODULE:
-                                        suffix = "_io_m";
-                                        break;
-                                    case DIST::l_COMMON:
-                                        suffix = "_io_c";
-                                        break;
-                                }
-                                
-                                auto copied_symbol = copyArray(decl_place, 
-                                                               array_p, 
-                                                               lines_by_file.second, 
-                                                               suffix + to_string(region->GetId()), 
-                                                               decl_place.first, 
-                                                               newDeclsToInclude, 
-                                                               copied_syms);
-                            
-                                // original declaration statement
-                                auto *decl_stmt = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
-
-                                if (!decl_stmt || !isArrayDeclaration(decl_stmt))
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-                                auto dynamic_array = checkAssumedShape(decl_stmt, array_name);  
-
-                                while (decl_stmt && !isSgExecutableStatement(decl_stmt))
-                                {
-                                    if (isArrayDeclaration(decl_stmt) &&
-                                        decl_stmt->expr(0) &&
-                                        decl_stmt->expr(0)->lhs() &&
-                                        decl_stmt->expr(0)->lhs()->symbol() == copied_symbol.second)
-                                    {
-                                        break;
-                                    }
-
-                                    decl_stmt = decl_stmt->lexNext();
-                                }
-                                
-                                // created declaration statement
-                                if (!decl_stmt || !isArrayDeclaration(decl_stmt))
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
-
-                                // insert !$SPF ANALYSIS(PROCESS_PRIVATE(array)) directive before declaration statement
-                                
-                                string dir_str;
-                                if (decl_stmt->comments())
-                                {
-                                    auto str_comment = string(decl_stmt->comments());
-                                    if (str_comment.size() && str_comment.back() != '\n')
-                                        dir_str += "\n";
-                                }
-
-                                dir_str += "!$SPF ANALYSIS(PROCESS_PRIVATE(" + string(copied_symbol.second->identifier()) + "))\n";
-                                decl_stmt->addComment(dir_str.c_str());
-                            
-                                created_copies.insert({ array_to_copy, copied_symbol.second });
-
-                                // make array copy allocatable in case of assumed-shape array
-                                if(dynamic_array)
-                                {
-                                    // insert allocatable keyword in declaration
-                                    auto *kword_list = decl_stmt->expr(2);
-                                    if (!findExprWithVariant(kword_list, ALLOCATABLE_OP))
-                                    {
-                                        if (!kword_list)
-                                        {
-                                            kword_list = new SgExprListExp();
-                                            decl_stmt->setExpression(2, *kword_list);
-                                        }
-                                        
-                                        while (kword_list->rhs())
-                                            kword_list = kword_list->rhs();
-                                        
-                                        if (kword_list->lhs())
-                                        {
-                                            kword_list->setRhs(new SgExprListExp());
-                                            kword_list = kword_list->rhs();
-                                        }
-
-                                        kword_list->setLhs(new SgExpression(ALLOCATABLE_OP));
-                                    }
-
-                                    // can't switch back to file with array usage
-                                    if (SgFile::switchToFile(current_file_name) == -1)
-                                        printInternalError(convertFileName(__FILE__).c_str(), __LINE__); 
-                                        
-                                    // insert allocate(a_l(lbound(a, 1):ubound(a,1),...)) statement
-                                    SgStatement* allocate_stmt_place = NULL;
-
                                    auto* func_stmt = curr_stmt->getScopeForDeclare();
+
+                                    SgStatement* insertPlace = NULL;
                                    for (auto iterator = func_stmt->lexNext();
-                                        iterator && !isSgExecutableStatement(iterator);
+                                        !isSgExecutableStatement(iterator) || isSPF_stat(iterator) &&
+                                        !(iterator->variant() == SPF_PARALLEL_REG_DIR || iterator->variant() == SPF_END_PARALLEL_REG_DIR);
                                        iterator = iterator->lexNext())
                                    {
-                                            allocate_stmt_place = iterator;
+                                        insertPlace = iterator;
                                    }

                                    //NULL - no decl stats in function!
-                                    if (!allocate_stmt_place)
-                                        allocate_stmt_place = func_stmt;
+                                    if (!insertPlace)
+                                        insertPlace = func_stmt;

-                                    auto *allocate_stmt_parent = allocate_stmt_place->controlParent();
-                                    if (allocate_stmt_parent->variant() == GLOBAL)
-                                        allocate_stmt_parent = allocate_stmt_place;
-                                    
-                                    auto *created_array_ref = new SgArrayRefExp(*copied_symbol.second);
+                                    auto st = insertPlace->controlParent();
+                                    if (st->variant() == GLOBAL)
+                                        st = insertPlace;

-                                    auto* dim_list = new SgExprListExp();
-                                    created_array_ref->setLhs(dim_list);
-                                    
-                                    int dim_len = array_p->GetSizes().size();
-                                    for (int i = 1; i <= dim_len; i++)
-                                    {
-                                        auto *lcall = new SgFunctionCallExp(*lbound_symb);
-                                        auto *rcall = new SgFunctionCallExp(*ubound_symb);
-                                        
-                                        for (auto *call : {lcall, rcall})
-                                        {
-                                            call->setLhs(new SgExprListExp());
+                                    auto& copied_symb = array_to_copy->copy();
+                                    copied.second = &copied_symb;

-                                            call->lhs()->setLhs(new SgArrayRefExp(*array_to_copy));
-                                            call->lhs()->setRhs(new SgValueExp(i));
-                                        }
-                                        
-                                        auto *dot_expr = new SgExpression(DDOT);
-                                        dot_expr->setLhs(lcall);
-                                        dot_expr->setRhs(rcall);
+                                    auto new_name = string(array_to_copy->identifier()) + "_io_c";
+                                    copied_symb.changeName(new_name.c_str());

-                                        dim_list->setLhs(dot_expr);
+                                    auto stat = array_to_copy->makeVarDeclStmt();
+                                    auto res = CalculateInteger(stat->expr(0)->copyPtr());
+                                    res->lhs()->setSymbol(copied_symb);
+                                    stat->setExpression(0, res);

-                                        if (i < dim_len)
-                                        {
-                                            auto *next = new SgExprListExp();
-                                            dim_list->setRhs(next);
-                                            dim_list = next;
-                                        }
-                                    }
-
-                                    auto *allocate_stmt = new SgStatement(ALLOCATE_STMT);
-                                    allocate_stmt->setExpression(0, created_array_ref);
-
-                                    allocate_stmt_place->insertStmtAfter(*allocate_stmt, *allocate_stmt_parent);
-
-                                    // insert deallocate statemens before all returns
-                                    auto *find_return_stmt = func_stmt;
-                                    while (find_return_stmt != func_stmt->lastNodeOfStmt())
-                                    {
-                                        auto *next = find_return_stmt->lexNext();
-                                        if (next && (isSgReturnStmt(next) || next == func_stmt->lastNodeOfStmt()))
-                                        {
-                                            if (next->hasLabel())
-                                            {
-                                                moveLabelBefore(next);
-                                                find_return_stmt = next->lexPrev();
-                                            }
-                                            
-                                            auto *dealloc_stmt = new SgStatement(DEALLOCATE_STMT);
-
-                                            dealloc_stmt->setExpression(0, new SgExprListExp());
-                                            dealloc_stmt->expr(0)->setLhs(new SgArrayRefExp(*copied_symbol.second));
-
-                                            find_return_stmt->insertStmtAfter(*dealloc_stmt, *next->controlParent());
-
-                                            if (next == curr_stmt)
-                                                curr_stmt = dealloc_stmt;
-                                        }
-
-                                        find_return_stmt = next;
-                                    }
+                                    insertPlace->insertStmtAfter(*stat, *st);
+                                }
+                                else
+                                {
+                                    copied = copyArray(place, array_p, linesByFile.second, suffix + to_string(region->GetId()), fileName, newDeclsToInclude, copied_syms);
                                }

-                                // can't switch back to file with array usage
-                                if (SgFile::switchToFile(current_file_name) == -1)
-                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__); 
+                                SgStatement* decl = SgStatement::getStatementByFileAndLine(place.first, place.second);
+
+                                if (decl)
+                                    decl = decl->lexNext();
+
+                                if (decl)
+                                {
+                                    string dir_str;
+                                    if (decl->comments())
+                                    {
+                                        string str_comment = string(decl->comments());
+                                        if (str_comment.size() && str_comment.back() != '\n')
+                                            dir_str += "\n";
+                                    }
+
+                                    dir_str += "!$SPF ANALYSIS(PROCESS_PRIVATE(" + string(copied.second->identifier()) + "))\n";
+                                    decl->addComment(dir_str.c_str());
+                                }
+                                created_copies.insert({ array_to_copy, copied.second });
                            }
                        }

@@ -837,9 +515,12 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                            {
                                auto it = created_copies.find(p.first);
                                if (it != created_copies.end())
-                                    replaceArrayInFragment(p.first, p.second, it->second, last_io_bound, curr_stmt, current_func_info);
+                                    replaceArrayInFragment(p.first, p.second, it->second, last_io_bound, curr_stmt, filename);
                                else
+                                {
                                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+                                    return;
+                                }
                            }
                        }

@@ -857,17 +538,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                        }
                    }

-                    auto need_fix_io = populateDistributedIoArrays(need_replace, curr_stmt, current_file_name, current_func_info);
-                    
-                    // incorrect IO statement with label
-                    // move label to dummy statement and insert copy statements between dummy statement and IO
-                    if (need_fix_io && curr_stmt->hasLabel())
-                    {
-                        moveLabelBefore(curr_stmt);
-                        if (last_io_bound == curr_stmt) // always true
-                            last_io_bound = curr_stmt->lexPrev();
-                    }
-
+                    populateDistributedIoArrays(need_replace, curr_stmt);
                    curr_stmt = curr_stmt->lexNext();
                }
            }
--- a/src/Transformations/SwapOperators/swap_operators.cpp
+++ b/src/Transformations/SwapOperators/swap_operators.cpp
@@ -0,0 +1,353 @@
+#include <map>
+#include <unordered_set>
+#include <vector>
+#include <queue>
+#include <iostream>
+
+#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 "swap_operators.h"
+
+using namespace std;
+
+
+unordered_set<int> loop_tags = {FOR_NODE/*, FORALL_NODE, WHILE_NODE, DO_WHILE_NODE*/};
+unordered_set<int> importantDepsTags = {FOR_NODE, IF_NODE};
+unordered_set<int> importantUpdDepsTags = {ELSEIF_NODE};
+unordered_set<int> importantEndTags = {CONTROL_END};
+
+
+vector<SAPFOR::IR_Block*> findInstructionsFromOperator(SgStatement* st, 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;
+}
+
+vector<SAPFOR::BasicBlock*> findFuncBlocksByFuncStatement(SgStatement *st, 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, 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())
+        {
+            // part with find statements of loop
+            SgForStmt *forSt = (SgForStmt*)st;
+            SgStatement *loopBody = forSt -> body();
+            SgStatement *lastLoopNode = st->lastNodeOfStmt();
+            // part with find blocks and instructions of loops
+            unordered_set<int> blocks_nums;
+            while (loopBody && loopBody != lastLoopNode)
+            {
+                SAPFOR::IR_Block* IR = findInstructionsFromOperator(loopBody, blocks).front();
+                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();
+            }
+            std::sort(result[forSt].begin(), result[forSt].end());
+        }
+        st = st -> lexNext();
+    }
+    return result;
+}
+
+map<SgStatement*, set<SgStatement*>> AnalyzeLoopAndFindDeps(SgForStmt* forStatement, vector<SAPFOR::BasicBlock*> loopBlocks, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR)
+{
+    map<SgStatement*, set<SgStatement*>> result;
+    for (SAPFOR::BasicBlock* bb: loopBlocks)
+    {
+        map<SAPFOR::Argument*, set<int>> blockReachingDefinitions = bb -> getRD_In();
+        vector<SAPFOR::IR_Block*> instructions = bb -> getInstructions();
+        for (SAPFOR::IR_Block* irBlock: instructions)
+        {
+            // TODO: Think about what to do with function calls and array references. Because there are also dependencies there that are not reflected in RD, but they must be taken into account
+            SAPFOR::Instruction* instr = irBlock -> getInstruction();
+            result[instr -> getOperator()];
+            // take Argument 1 and it's RD and push operators to final set
+            if (instr -> getArg1() != NULL)
+            {
+                SAPFOR::Argument* arg = instr -> getArg1();
+                set<int> prevInstructionsNumbers = blockReachingDefinitions[arg];
+                for (int i: prevInstructionsNumbers)
+                {
+                    SAPFOR::Instruction* foundInstruction = getInstructionAndBlockByNumber(FullIR, i).first;
+                    if (foundInstruction != NULL)
+                    {
+                        SgStatement* prevOp = foundInstruction -> getOperator();
+                        if (prevOp != forStatement && instr -> getOperator() != forStatement && instr -> getOperator() -> lineNumber() > prevOp -> lineNumber()
+                            && prevOp -> lineNumber() > forStatement -> lineNumber())
+                            result[instr -> getOperator()].insert(prevOp);
+                    }
+                }
+            }
+            // take Argument 2 (if exists) and it's RD and push operators to final set
+            if (instr -> getArg2() != NULL)
+            {
+                SAPFOR::Argument* arg = instr -> getArg2();
+                set<int> prevInstructionsNumbers = blockReachingDefinitions[arg];
+                for (int i: prevInstructionsNumbers)
+                {
+                    SAPFOR::Instruction* foundInstruction = getInstructionAndBlockByNumber(FullIR, i).first;
+                    if (foundInstruction != NULL)
+                    {
+                        SgStatement* prevOp = foundInstruction -> getOperator();
+                        if (prevOp != forStatement && instr -> getOperator() != forStatement&& instr -> getOperator() -> lineNumber() > prevOp -> lineNumber()
+                            && prevOp -> lineNumber() > forStatement -> lineNumber())
+                            result[instr -> getOperator()].insert(prevOp);
+                    }
+                }
+            }
+            // update RD
+            if (instr -> getResult() != NULL)
+                blockReachingDefinitions[instr -> getResult()] = {instr -> getNumber()};
+        }
+    }
+    return result;
+}
+
+void buildAdditionalDeps(SgForStmt* forStatement, map<SgStatement*, set<SgStatement*>>& dependencies)
+{
+    SgStatement* lastNode = forStatement->lastNodeOfStmt();
+    vector<SgStatement*> importantDeps;
+    SgStatement* st = (SgStatement*) forStatement;
+    st = st -> lexNext();
+    SgStatement* logIfOp = NULL;
+    while (st && st != lastNode)
+    {
+        if(importantDeps.size() != 0)
+        {
+            if (st != importantDeps.back())
+            {
+                dependencies[st].insert(importantDeps.back());
+            }
+        }
+        if (logIfOp != NULL)
+        {
+            dependencies[st].insert(logIfOp);
+            logIfOp = NULL;
+        }
+        if (st -> variant() == LOGIF_NODE)
+        {
+            logIfOp = st;
+        }
+        if (importantDepsTags.find(st -> variant()) != importantDepsTags.end())
+        {
+            importantDeps.push_back(st);
+        }
+        if (importantUpdDepsTags.find(st -> variant()) != importantUpdDepsTags.end())
+        {
+            importantDeps.pop_back();
+            importantDeps.push_back(st);
+        }
+        if (importantEndTags.find(st -> variant()) != importantEndTags.end())
+        {
+            if(importantDeps.size() != 0)
+            {
+                importantDeps.pop_back();
+            }
+        }
+        st = st -> lexNext();
+    }
+}
+
+struct ReadyOp {
+    SgStatement* stmt;
+    int degree;
+    size_t arrival;
+    ReadyOp(SgStatement* s, int d, size_t a): stmt(s), degree(d), arrival(a) {}
+};
+
+struct ReadyOpCompare {
+    bool operator()(const ReadyOp& a, const ReadyOp& b) const {
+        if (a.degree != b.degree)
+            return a.degree > b.degree;
+        else
+            return a.arrival > b.arrival;
+    }
+};
+
+vector<SgStatement*> scheduleOperations(const map<SgStatement*, set<SgStatement*>>& dependencies)
+{
+    // get all statements
+    unordered_set<SgStatement*> allStmtsSet;
+    for (const auto& pair : dependencies)
+    {
+        allStmtsSet.insert(pair.first);
+        for (SgStatement* dep : pair.second)
+        {
+            allStmtsSet.insert(dep);
+        }
+    }
+    vector<SgStatement*> allStmts(allStmtsSet.begin(), allStmtsSet.end());
+    // count deps and build reversed graph
+    unordered_map<SgStatement*, vector<SgStatement*>> graph;
+    unordered_map<SgStatement*, int> inDegree;
+    unordered_map<SgStatement*, int> degree;
+    for (auto op : allStmts)
+        inDegree[op] = 0;
+    // find and remember initial dependencies
+    unordered_set<SgStatement*> dependentStmts;
+    for (const auto& pair : dependencies)
+    {
+        SgStatement* op = pair.first;
+        const auto& deps = pair.second;
+        degree[op] = deps.size();
+        inDegree[op] = deps.size();
+        if (!deps.empty())
+            dependentStmts.insert(op);
+        for (auto dep : deps)
+            graph[dep].push_back(op);
+    }
+    for (SgStatement* op : allStmts)
+    {
+        if (!degree.count(op))
+        {
+            degree[op] = 0;
+        }
+    }
+    // build queues
+    using PQ = priority_queue<ReadyOp, vector<ReadyOp>, ReadyOpCompare>;
+    PQ readyDependent;
+    queue<SgStatement*> readyIndependent;
+    size_t arrivalCounter = 0;
+    for (auto op : allStmts)
+    {
+        if (inDegree[op] == 0)
+        {
+            if (dependentStmts.count(op))
+            {
+                readyDependent.emplace(op, degree[op], arrivalCounter++);
+            }
+            else
+            {
+                readyIndependent.push(op);
+            }
+        }
+    }
+    // main sort algorythm
+    vector<SgStatement*> executionOrder;
+    while (!readyDependent.empty() || !readyIndependent.empty())
+    {
+        SgStatement* current = nullptr;
+        if (!readyDependent.empty())
+        {
+            current = readyDependent.top().stmt;
+            readyDependent.pop();
+        }
+        else
+        {
+            current = readyIndependent.front();
+            readyIndependent.pop();
+        }
+        executionOrder.push_back(current);
+        for (SgStatement* neighbor : graph[current])
+        {
+            inDegree[neighbor]--;
+            if (inDegree[neighbor] == 0) {
+                if (dependentStmts.count(neighbor))
+                {
+                    readyDependent.emplace(neighbor, degree[neighbor], arrivalCounter++);
+                }
+                else
+                {
+                    readyIndependent.push(neighbor);
+                }
+            }
+        }
+    }
+    return executionOrder;
+}
+
+void buildNewAST(SgStatement* loop, vector<SgStatement*>& newBody)
+{
+    SgStatement* endDo = loop->lastNodeOfStmt();
+    SgStatement* st = loop;
+    int lineNum = loop -> lineNumber() + 1;
+    for (int i = 0; i < newBody.size(); i++)
+    {
+        st -> setLexNext(*newBody[i]);
+        st = st -> lexNext();
+        st -> setlineNumber(lineNum);
+        lineNum++;
+    }
+    st -> setLexNext(*endDo);
+}
+
+
+
+void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform)
+{
+    std::cout << "SWAP_OPERATORS Pass" << std::endl;    // to remove
+    countOfTransform += 1;                              // to remove
+
+    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 (pair<SgForStmt*, vector<SAPFOR::BasicBlock*>> loopForAnalyze: loopsMapping)
+        {
+            map<SgStatement*, set<SgStatement*>> dependencyGraph = AnalyzeLoopAndFindDeps(loopForAnalyze.first, loopForAnalyze.second, FullIR);
+            // TODO: Write a function that will go through the operators and update all dependencies so that there are no mix-ups and splits inside the semantic blocks (for if, do and may be some other cases)
+            buildAdditionalDeps(loopForAnalyze.first, dependencyGraph);
+            cout << endl;
+            int firstLine = loopForAnalyze.first -> lineNumber();
+            int lastLine = loopForAnalyze.first -> lastNodeOfStmt() -> lineNumber();
+            cout << "LOOP ANALYZE FROM " << firstLine << " TO " << lastLine << " RES" << endl;
+            // for (auto &v: dependencyGraph) {
+            //     cout << "OPERATOR: " << v.first -> lineNumber()  << "    " << v.first -> variant() << "\nDEPENDS ON:" << endl;
+            //     if (v.second.size() != 0)
+            //         for (auto vv: v.second)
+            //             cout << vv -> lineNumber() << "  ";
+            //     cout << endl;
+            // }
+            vector<SgStatement*> new_order = scheduleOperations(dependencyGraph);
+            cout << "RESULT ORDER:" << endl;
+            for (auto v: new_order) 
+                if (v -> lineNumber() > firstLine) 
+                    cout << v -> lineNumber() << endl;
+            buildNewAST(loopForAnalyze.first, new_order);
+            st = loopForAnalyze.first -> lexNext();
+            while (st != loopForAnalyze.first -> lastNodeOfStmt())
+            {
+                cout << st -> lineNumber() << "    " << st -> sunparse() << endl;
+                st = st -> lexNext();
+            }
+        }
+    }
+
+    return;
+};
--- a/src/Transformations/SwapOperators/swap_operators.h
+++ b/src/Transformations/SwapOperators/swap_operators.h
@@ -0,0 +1,6 @@
+#pragma once
+
+#include "../../GraphLoop/graph_loops.h"
+#include "../../CFGraph/CFGraph.h"
+
+void runSwapOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);
--- a/src/Utils/PassManager.h
+++ b/src/Utils/PassManager.h
@@ -212,6 +212,8 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>

    Pass(BUILD_IR) <= Pass(SUBST_EXPR_RD) <= Pass(SUBST_EXPR_RD_AND_UNPARSE);

+    list({BUILD_IR, CALL_GRAPH2}) <= Pass(SWAP_OPERATORS);
+
    list({ LOOP_ANALYZER_DATA_DIST_S1, SUBST_EXPR_RD } ) <= Pass(PRIVATE_REMOVING_ANALYSIS);
    list({ PRIVATE_REMOVING_ANALYSIS, REVERT_SUBST_EXPR_RD }) <= Pass(PRIVATE_REMOVING);

@@ -316,8 +318,7 @@ void InitPassesDependencies(map<passes, vector<passes>> &passDepsIn, set<passes>

    list({ VERIFY_INCLUDES, CORRECT_VAR_DECL }) <= Pass(SET_IMPLICIT_NONE);

-    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({ CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH, LOOP_ANALYZER_DATA_DIST_S2 }) <= Pass(FIND_PRIVATE_ARRAYS);

    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,
--- a/src/Utils/utils.cpp
+++ b/src/Utils/utils.cpp
@@ -390,15 +390,32 @@ void clearGlobalBuffer() { globalOutputBuffer = ""; }
 const string& getGlobalBuffer() { return globalOutputBuffer; }

 set<short*> allocated;
+set<int*> allocatedInt;
+static void convertGlobalBuffer(short *&result, int *&resultSize)
+{
+    const unsigned len = (unsigned)globalOutputBuffer.size();
+    result = new short[len + 1];
+    allocated.insert(result);
+
+    result[len] = '\0';
+    for (unsigned i = 0; i < len; ++i)
+        result[i] = globalOutputBuffer[i];
+
+    resultSize = new int[1];
+    resultSize[0] = (int)len;
+}
+
 extern map<string, vector<Messages>> SPF_messages; //file ->messages
 void clearGlobalMessagesBuffer()
 {
    //clear allocated memory
    for (auto& elem : allocated)
-        delete []elem;    
+        delete[]elem;
+    for (auto& elem : allocatedInt)
+        delete[]elem;
    allocated.clear();
-    
-    
+    allocatedInt.clear();
+
    SPF_messages.clear();
 }

@@ -434,7 +451,7 @@ static map<string, vector<Messages>> removeCopies(map<string, vector<Messages>>
    return out;
 }

-static string convertGlobalMessagesBuffer()
+static void convertGlobalMessagesBuffer(short *&result, int *&resultSize)
 {
    auto copySPF_messages = removeCopies(SPF_messages);
    for (auto &byFile : copySPF_messages)
@@ -472,13 +489,21 @@ static string convertGlobalMessagesBuffer()
    json all;
    all["allMessages"] = allMessages;

-    return all.dump();    
+    const string str = all.dump();    
+    const unsigned len = (unsigned)str.size();
+
+    copyStringToShort(result, str);
+    allocated.insert(result);
+
+    resultSize = new int[1];
+    resultSize[0] = (int)len;
 }

-void convertBuffers(string &resultM, string &result)
+
+void convertBuffers(short*& resultM, int*& resultSizeM, short*& result, int*& resultSize)
 {
-    resultM = convertGlobalMessagesBuffer();
-    result = getGlobalBuffer();
+    convertGlobalMessagesBuffer(resultM, resultSizeM);
+    convertGlobalBuffer(result, resultSize);
 }

 bool isSPF_comment(const string &bufStr)
--- a/src/Utils/utils.h
+++ b/src/Utils/utils.h
@@ -33,7 +33,7 @@ void addToGlobalBufferAndPrint(const std::string &toPrint);
 void clearGlobalBuffer();
 const std::string& getGlobalBuffer();
 std::wstring to_wstring(const std::string);
-void convertBuffers(std::string& resultM, std::string& result);
+void convertBuffers(short*& resultM, int*& resultSizeM, short*& result, int*& resultSize);
 void clearGlobalMessagesBuffer();
 std::string renameInclude(const std::string& inc);
 void copyIncludes(const std::set<std::string> &allIncludeFiles, const std::map<std::string, std::map<int, std::set<std::string>>> &commentsToInclude, const std::map<std::string, std::map<int, std::set<std::string>>>& newCopyDeclToIncl, const char *folderName, bool keepSpfDirs, bool isFreeStyle, bool isRename, int removeDirs = 0);
--- a/src/Utils/version.h
+++ b/src/Utils/version.h
@@ -1,3 +1,3 @@
 #pragma once

-#define VERSION_SPF "2450"
+#define VERSION_SPF "2436"
--- a/src/VisualizerCalls/get_information.cpp
+++ b/src/VisualizerCalls/get_information.cpp
Author	SHA1	Message	Date
Alexander	b298cc03bf	moved to transformations	2025-07-09 14:46:38 +03:00
Egor Mayorov	8c6a55463c	swap operators in AST	2025-07-09 14:46:38 +03:00
Egor Mayorov	32a4a7fd0a	Use more complex algorythm for building new order of statements	2025-07-09 14:46:38 +03:00
Egor Mayorov	507305ac3a	update in new order	2025-07-09 14:46:38 +03:00
Egor Mayorov	a3939ed274	biulding new order	2025-07-09 14:46:38 +03:00
Egor Mayorov	95ef954b6e	some loop analysis done	2025-07-09 14:46:38 +03:00
Egor Mayorov	243b1f5bdb	Add _bin to gitignore	2025-07-09 14:46:38 +03:00
Egor Mayorov	5fb2bd79df	Some actions simplify analyzing IR	2025-07-09 14:46:37 +03:00
Egor Mayorov	d33659290e	Pass with output file added	2025-07-09 14:46:37 +03:00
Egor Mayorov	b8a6c92ca8	change pass deps	2025-07-09 14:46:37 +03:00
Egor Mayorov	1028e20177	New pass	2025-07-09 14:46:37 +03:00