refactored

marge_regions: rename
2026-04-19 20:29:23 +03:00 · 2026-04-19 20:25:20 +03:00 · 2026-04-19 19:17:14 +03:00 · 2026-04-19 18:32:50 +03:00 · 2026-04-19 18:32:50 +03:00 · 2026-04-19 18:32:49 +03:00
31 changed files with 2251 additions and 1091 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -161,11 +161,15 @@ set(PARALLEL_REG src/ParallelizationRegions/ParRegions.cpp
        src/ParallelizationRegions/expand_extract_reg.cpp
        src/ParallelizationRegions/expand_extract_reg.h
        src/ParallelizationRegions/resolve_par_reg_conflicts.cpp
-        src/ParallelizationRegions/resolve_par_reg_conflicts.h)
+        src/ParallelizationRegions/resolve_par_reg_conflicts.h
+        src/ParallelizationRegions/uniq_name_creator.cpp
+        src/ParallelizationRegions/uniq_name_creator.h)

 set(ARRAY_PROP src/ArrayConstantPropagation/propagation.cpp
 	src/ArrayConstantPropagation/propagation.h	
 )
+set(MERGE_REGIONS src/ParallelizationRegions/merge_regions.cpp
+         src/ParallelizationRegions/merge_regions.h)

 set(TR_DEAD_CODE src/Transformations/DeadCodeRemoving/dead_code.cpp
        src/Transformations/DeadCodeRemoving/dead_code.h)
@@ -426,6 +430,7 @@ set(SOURCE_EXE
    ${LOOP_ANALYZER}
    ${TRANSFORMS}
    ${PARALLEL_REG}
+    ${MERGE_REGIONS}
    ${PRIV}
    ${ARRAY_PROP}
    ${FDVM}
@@ -479,6 +484,7 @@ source_group (GraphCall FILES ${GR_CALL})
 source_group (GraphLoop FILES ${GR_LOOP})
 source_group (LoopAnalyzer FILES ${LOOP_ANALYZER})
 source_group (ParallelizationRegions FILES ${PARALLEL_REG})
+source_group (MergeRegions FILES ${MERGE_REGIONS})
 source_group (PrivateAnalyzer FILES ${PRIV})      
 source_group (ArrayConstantPropagation FILES ${ARRAY_PROP})      
 source_group (FDVM_Compiler FILES ${FDVM})
--- a/projects/dvm
+++ b/projects/dvm
--- a/projects/libpredictor
+++ b/projects/libpredictor
--- a/src/ArrayConstantPropagation/propagation.cpp
+++ b/src/ArrayConstantPropagation/propagation.cpp
@@ -3,13 +3,35 @@
 #include "../Utils/SgUtils.h"

 #include <iostream>
+#include <functional>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>

 using namespace std;

-static SgStatement* declPlace = NULL;
+namespace {
+
+    struct MyHash {
+        size_t operator()(const SgSymbol* s) const {
+            return std::hash<std::string_view>{}(s->identifier());
+        }
+    };
+
+    struct MyEq {
+        bool operator()(const SgSymbol* a, const SgSymbol* b) const {
+            return std::strcmp(a->identifier(), b->identifier()) == 0;
+        }
+    };
+
+}
+
+SgStatement* declPlace = NULL;
+unordered_set<SgStatement*> changed;
+unordered_set<SgSymbol*, MyHash, MyEq> variablesToAdd;
+unordered_set<SgStatement*> positionsToAdd;
+unordered_set<SgStatement*> statementsToRemove;
+unordered_map<string, vector<pair<SgStatement*, SgStatement*>>> expToChange;

 static bool CheckConstIndexes(SgExpression* exp)
 {
@@ -40,158 +62,148 @@ static SgExpression* CreateVar(int& variableNumber, SgType* type)
    string name = varName + std::to_string(variableNumber) + "__";
    variableNumber++;

-    SgSymbol* varSymbol = new SgSymbol(VARIABLE_NAME, name.c_str(), *type, *declPlace->controlParent());
+    SgStatement* funcStart = declPlace->controlParent();
+    SgSymbol* varSymbol = new SgSymbol(VARIABLE_NAME, name.c_str(), *type, *funcStart);
+
+    variablesToAdd.insert(varSymbol);
+    positionsToAdd.insert(declPlace);
+
+    return new SgExpression(VAR_REF, NULL, NULL, varSymbol, type->copyPtr());
+}
+
+static SgStatement* FindLastDeclStatement(SgStatement* funcStart)
+{
+    SgStatement* endSt = funcStart->lastNodeOfStmt();
+    SgStatement* cur = funcStart->lexNext();
+    SgStatement* lastDecl = funcStart;
+    const set<int> declVariants = { VAR_DECL, VAR_DECL_90, ALLOCATABLE_STMT, DIM_STAT,
+                                    EXTERN_STAT, COMM_STAT, HPF_TEMPLATE_STAT, DVM_VAR_DECL, STRUCT_DECL };
+
+    while (cur && cur != endSt)
+    {
+        if (cur->variant() == INTERFACE_STMT)
+            cur = cur->lastNodeOfStmt();
+
+        if (declVariants.find(cur->variant()) != declVariants.end())
+            lastDecl = cur;
+        else if (isSgExecutableStatement(cur))
+            break;
+
+        cur = cur->lexNext();
+    }
+
+    return lastDecl;
+}
+
+static void InsertCommonAndDeclsForFunction(SgStatement* funcStart, const unordered_set<SgSymbol*, MyHash, MyEq>& symbols)
+{
+    if (symbols.empty())
+        return;

    const string commonBlockName = "__propagation_common__";

-    SgStatement* funcStart = declPlace->controlParent();
+    SgStatement* funcEnd = funcStart->lastNodeOfStmt();
    SgStatement* commonStat = NULL;
    SgExpression* commonList = NULL;

-    SgStatement* funcEnd = funcStart->lastNodeOfStmt();
-    SgStatement* current = funcStart->lexNext();
-
-    while (current != funcEnd && current)
+    for (SgStatement* cur = funcStart->lexNext();
+         cur && cur != funcEnd; cur = cur->lexNext())
    {
-        if (current->variant() == COMM_STAT)
+        if (cur->variant() != COMM_STAT)
+            continue;
+
+        for (SgExpression* exp = cur->expr(0); exp; exp = exp->rhs())
        {
-            for (SgExpression* exp = current->expr(0); exp; exp = exp->rhs())
+            if (exp->variant() != COMM_LIST)
+                continue;
+
+            const char* id = exp->symbol() ? exp->symbol()->identifier() : NULL;
+            string existingName = id ? string(id) : string("spf_unnamed");
+            if (existingName == commonBlockName)
            {
-                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)
+                commonStat = cur;
+                commonList = exp;
                break;
+            }
        }
-        current = current->lexNext();
+        if (commonStat)
+            break;
    }

    vector<SgExpression*> varRefs;
-    if (commonList)
+    for (SgSymbol* sym : symbols)
    {
-        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 (!sym || sym->variant() != VARIABLE_NAME || string(sym->identifier()) == commonBlockName)
+            continue;
+        SgSymbol* symToAdd = new SgSymbol(VARIABLE_NAME, sym->identifier(), *sym->type(), *funcStart);
+        varRefs.push_back(new SgVarRefExp(symToAdd));
+    }
+    SgExpression* varList = makeExprList(varRefs, false);
+
+    SgStatement* insertAfter = FindLastDeclStatement(funcStart);
+    for (SgSymbol* sym : symbols)
+    {
+        SgStatement* declStmt = sym->makeVarDeclStmt();
+        if (!declStmt)
+            continue;
+
+        if (SgVarDeclStmt* vds = isSgVarDeclStmt(declStmt))
+            vds->setVariant(VAR_DECL_90);
+
+        declStmt->setFileName(funcStart->fileName());
+        declStmt->setFileId(funcStart->getFileId());
+        declStmt->setProject(funcStart->getProject());
+        declStmt->setlineNumber(getNextNegativeLineNumber());
+
+        insertAfter->insertStmtAfter(*declStmt, *funcStart);
+        insertAfter = declStmt;
+        statementsToRemove.insert(declStmt);
    }

    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);
+        commonList = new SgExpression(COMM_LIST, varList, 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());
-        }
+        commonStat = new SgStatement(COMM_STAT);
+        commonStat->setFileName(funcStart->fileName());
+        commonStat->setFileId(funcStart->getFileId());
+        commonStat->setProject(funcStart->getProject());
+        commonStat->setlineNumber(getNextNegativeLineNumber());
+        commonStat->setExpression(0, commonList);

+        SgStatement* lastDecl = FindLastDeclStatement(funcStart);
+        lastDecl->insertStmtAfter(*commonStat, *funcStart);
+        statementsToRemove.insert(commonStat);
    }
-    varRefs.push_back(new SgVarRefExp(varSymbol));
-
-    if (varRefs.size() > 0)
+    else
    {
-        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;
+        expUnparsed = exp->unparse();
        if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
        {
            arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());  
        }
-        st->setExpression(1, arrayToVariable[expUnparsed]->copyPtr());
+        positionsToAdd.insert(declPlace);
+        SgSymbol* builder = arrayToVariable[expUnparsed]->symbol();
+        auto* sym = new SgSymbol(builder->variant(), builder->identifier(), builder->type(), st->controlParent());
+        auto* newVarExp = new SgVarRefExp(sym);
+        expToChange[st->fileName()].push_back({ st , st->copyPtr() });
+        st->setExpression(1, newVarExp);
        return;
    }
    for (int i = 0; i < 2; i++)
@@ -199,27 +211,30 @@ static void TransformRightPart(SgStatement* st, SgExpression* exp, unordered_map
        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 (arrayToVariable.find(expUnparsed) == arrayToVariable.end())               
+                arrayToVariable[expUnparsed] = CreateVar(variableNumber, subnodes[i]->symbol()->type()->baseType());
+
+            positionsToAdd.insert(declPlace);
+            SgSymbol* builder = arrayToVariable[expUnparsed]->symbol();
+            auto* sym = new SgSymbol(builder->variant(), builder->identifier(), builder->type(), st->controlParent());
+            toAdd = new SgVarRefExp(sym);
            if (toAdd)
            {
                if (i == 0)
                {
+                    expToChange[st->fileName()].push_back({ st , st->copyPtr() });;
                    exp->setLhs(toAdd);
                }
                else
                {
+                    expToChange[st->fileName()].push_back({ st , st->copyPtr() });;
                    exp->setRhs(toAdd);
                }
            }
        }
        else
-        {
            TransformRightPart(st, subnodes[i], arrayToVariable, variableNumber);
-        }
+        
    }
 }

@@ -227,11 +242,14 @@ static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<
 {
    if (exp->symbol()->type()->variant() == T_STRING)
        return;
+    if (changed.find(st) != changed.end())
+        return;
    string expUnparsed = exp->unparse();
    if (arrayToVariable.find(expUnparsed) == arrayToVariable.end() && exp->symbol()->type()->baseType())
    {
        arrayToVariable[expUnparsed] = CreateVar(variableNumber, exp->symbol()->type()->baseType());
    }
+    positionsToAdd.insert(declPlace);
    SgStatement* newStatement = new SgStatement(ASSIGN_STAT, NULL, NULL, arrayToVariable[expUnparsed]->copyPtr(), st->expr(1)->copyPtr(), NULL);

    newStatement->setFileId(st->getFileId());
@@ -240,9 +258,62 @@ static void TransformLeftPart(SgStatement* st, SgExpression* exp, unordered_map<
    newStatement->setlineNumber(getNextNegativeLineNumber());
    newStatement->setLocalLineNumber(st->lineNumber());
    st->insertStmtBefore(*newStatement, *st->controlParent());
+    changed.insert(st);
+    statementsToRemove.insert(newStatement);
 }

-void ArrayConstantPropagation(SgProject& project) 
+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();
+    if (arrayToVariable.find(array) == arrayToVariable.end())
+        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);
+            positionsToAdd.insert(declPlace);
+        }
+        if (st->variant() == ASSIGN_STAT && arrayToVariable.find(st->expr(0)->unparse()) != arrayToVariable.end())
+        {
+            if (st->expr(1))
+            {
+                TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
+                positionsToAdd.insert(declPlace);
+            }
+            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);
+                positionsToAdd.insert(declPlace);
+            }
+        }
+        st = st->lexPrev();
+    }
+}
+
+void arrayConstantPropagation(SgProject& project) 
 {
    unordered_map<string, SgExpression*> arrayToVariable;
    int variableNumber = 0;
@@ -252,7 +323,7 @@ void ArrayConstantPropagation(SgProject& project)

        if (!file)
            continue;
-
+        SgFile::switchToFile(file->filename());
        const int funcNum = file->numberOfFunctions();
        for (int i = 0; i < funcNum; ++i)
        {
@@ -262,40 +333,48 @@ void ArrayConstantPropagation(SgProject& project)

            for (; st != lastNode; st = st->lexNext())
            {
-                if (st->variant() == ASSIGN_STAT)
-                {
-                    if (st->expr(1))
-                    {
-                        TransformRightPart(st, st->expr(1), arrayToVariable, variableNumber);
-                    }
-                    if (st->expr(0) && st->expr(0)->variant() == ARRAY_REF && CheckConstIndexes(st->expr(0)->lhs()))
-                    {
-                        TransformLeftPart(st, st->expr(0), arrayToVariable, variableNumber);
-                    }
-                }
-                else if (st->variant() == FOR_NODE)
+                if (st->variant() == FOR_NODE)
                {
                    SgExpression* lowerBound = st->expr(0)->lhs();
                    SgExpression* upperBound = st->expr(0)->rhs();
+                    SgStatement* boundCopy = NULL;
                    string lowerBoundUnparsed = lowerBound->unparse(), upperBoundUnparsed = upperBound->unparse();
                    if (upperBound->variant() == ARRAY_REF && upperBound->symbol()->type()->baseType() && CheckConstIndexes(upperBound->lhs()))
                    {
-                        if (arrayToVariable.find(upperBoundUnparsed) == arrayToVariable.end())
-                        {
-                            arrayToVariable[upperBoundUnparsed] = CreateVar(variableNumber, upperBound->symbol()->type()->baseType());
-                        }
+                        boundCopy = st->copyPtr();
+                        TransformBorder(st, upperBound, arrayToVariable, variableNumber);
                        st->expr(0)->setRhs(arrayToVariable[upperBoundUnparsed]->copyPtr());
+                        expToChange[st->fileName()].push_back({ st ,boundCopy });;
+                        positionsToAdd.insert(declPlace);
                    }
+                    else if (upperBound->variant() == VAR_REF)
+                        CheckVariable(st, upperBound, arrayToVariable, variableNumber);
+
                    if (lowerBound->variant() == ARRAY_REF && lowerBound->symbol()->type()->baseType() && CheckConstIndexes(lowerBound->lhs()))
                    {
-                        if (arrayToVariable.find(lowerBoundUnparsed) == arrayToVariable.end())
-                        {
-                            arrayToVariable[lowerBoundUnparsed] = CreateVar(variableNumber, lowerBound->symbol()->type()->baseType());
-                        }
+                        boundCopy = st->copyPtr();
+                        TransformBorder(st, lowerBound, arrayToVariable, variableNumber);
                        st->expr(0)->setLhs(arrayToVariable[lowerBoundUnparsed]->copyPtr());
+                        expToChange[st->fileName()].push_back({ st , boundCopy });;
+                        positionsToAdd.insert(declPlace);
                    }
+                    else if (lowerBound->variant() == VAR_REF)
+                        CheckVariable(st, lowerBound, arrayToVariable, variableNumber);
                }
            }
        }
    }
+    unordered_set<SgStatement*> funcStarts;
+    for (SgStatement* st : positionsToAdd)
+    {
+        SgFile::switchToFile(st->fileName());
+        SgStatement* scope = st->controlParent();
+        if (scope)
+            funcStarts.insert(scope);
+    }
+    for (const auto& st : funcStarts)
+    {
+        SgFile::switchToFile(st->fileName());
+        InsertCommonAndDeclsForFunction(st, variablesToAdd);
+    }
 }
--- a/src/ArrayConstantPropagation/propagation.h
+++ b/src/ArrayConstantPropagation/propagation.h
@@ -1,4 +1,20 @@
 #pragma once
 #include "../Utils/SgUtils.h"

-void ArrayConstantPropagation(SgProject& project);
+#include <string>
+#include <vector>
+
+using namespace std;
+
+struct ExprRestoreEntry
+{
+    enum Kind { kStatementExpr, kExprChild };
+    Kind kind;
+    SgStatement* stmt;
+    int stmtExprIndex;
+    SgExpression* parent;
+    bool childIsRhs;
+    SgExpression* savedCopy;
+};
+
+void arrayConstantPropagation(SgProject& project);
--- a/src/CreateInterTree/CreateInterTree.cpp
+++ b/src/CreateInterTree/CreateInterTree.cpp
@@ -17,7 +17,7 @@ using std::fstream;
 static long int getNextTag()
 {
    static long int INTERVAL_TAG = 0;
-    return INTERVAL_TAG++;
+    return -(INTERVAL_TAG++);
 }

 //Debug funcs
@@ -413,7 +413,7 @@ static void findIntervals(SpfInterval *interval, map<int, int> &labelsRef, map<i
        inter->lineFile = std::make_pair(currentSt->lineNumber(), currentSt->fileName());
        inter->parent = interval;
        inter->exit_levels.push_back(0);
-        inter->tag = getNextTag();
+        inter->tag = currentSt->lineNumber();//getNextTag();
        interval->nested.push_back(inter);

        findIntervals(inter, labelsRef, gotoStmts, currentSt);
--- a/src/DvmhRegions/DvmhRegionInserter.cpp
+++ b/src/DvmhRegions/DvmhRegionInserter.cpp
@@ -1289,6 +1289,9 @@ static set<DIST::Array*>

            SgStatement* declStat = NULL;

+            if (realArray->GetLocation().first == DIST::l_PARAMETER)
+                continue;
+
            if (realArray->GetLocation().first == DIST::l_COMMON)
            {
                commonArrays.insert(realArray);
--- a/src/GraphCall/graph_calls.cpp
+++ b/src/GraphCall/graph_calls.cpp
@@ -723,7 +723,7 @@ static void fillIn(FuncInfo *currF, SgExpression *ex, const map<string, int> &pa
 {
    if (ex)
    {
-        if (!isInFuncPar && (ex->variant() == VAR_REF || isArrayRef(ex)))
+        if (!isInFuncPar && (ex->variant() == VAR_REF || ex->variant() == ARRAY_REF))
        {
            const char *name = ex->symbol()->identifier();
            if (name && name != string(""))
@@ -800,29 +800,58 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co

    static map<string, vector<int>> supportedKeyWordArg = { {"system_clock", { OUT_BIT, OUT_BIT, OUT_BIT } } };

-    map<string, int> parNames;
+    map<string, int> parNamesMain;
+    map<string, int> parNamesContains;

    for (int i = 0; i < currF->funcParams.identificators.size(); ++i)
-        parNames[currF->funcParams.identificators[i]] = i;
+        parNamesMain[currF->funcParams.identificators[i]] = i;

+    map<string, int>& parNames = parNamesMain;
+
+    bool isContainsFunctions = false;
    for (auto st = start; st != last; st = st->lexNext())
    {
-        if (st->variant() == CONTAINS_STMT)
-            break;
+        if (st->variant() == CONTAINS_STMT) {
+            isContainsFunctions = true;
+            continue;
+        }
+
+        if (isContainsFunctions) {
+            if (st->variant() == PROC_HEDR || st->variant() == FUNC_HEDR) {
+                parNamesContains = parNamesMain;
+                
+                SgProgHedrStmt* hedr = (SgProgHedrStmt*)st;
+
+                int numOfParams = hedr->numberOfParameters();
+                if (numOfParams > 0)
+                {
+                    for (int i = 0; i < numOfParams; ++i)
+                    {
+                        auto it = parNamesContains.find(hedr->parameter(i)->identifier());
+                        if (it != parNamesContains.end())
+                            parNamesContains.erase(it);
+                    }
+                }
+                parNames = parNamesContains;
+            }
+        }

        if (st->variant() == ENTRY_STAT)
            continue;
        
        if (isSgExecutableStatement(st) == NULL) {
-            checkInTypeDescription(st->expr(0), currF, parNames);
+            if (!isContainsFunctions)
+                checkInTypeDescription(st->expr(0), currF, parNames);
            continue;
        }

        if (st->lineNumber() <= 0)
            continue;

-        if (activeOps.size() && activeOps.find(st) == activeOps.end())
-            continue;
+        //XXX: use parameters removing in block ... isContainsFunctions ...
+        //TODO need to use IR for parameters checking
+        /*if (activeOps.size() && activeOps.find(st) == activeOps.end())
+            continue; */

        if (st->variant() == ASSIGN_STAT)
        {
@@ -851,7 +880,7 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
            for (auto ex = read->itemList(); ex; ex = ex->rhs())
            {
                SgExpression* item = ex->lhs();
-                if (item->variant() == VAR_REF || isArrayRef(item))
+                if (item && (item->variant() == VAR_REF || item->variant() == ARRAY_REF))
                {
                    string symb = "";
                    if (item->symbol())
@@ -872,7 +901,7 @@ static void fillInOut(FuncInfo *currF, SgStatement *start, SgStatement *last, co
                        if (item->rhs())
                            queue.push(item->rhs());

-                        if (item->variant() == VAR_REF || isArrayRef(item))
+                        if (item->variant() == VAR_REF || item->variant() == ARRAY_REF)
                        {
                            string symb = "";
                            if (item->symbol())
--- a/src/ParallelizationRegions/ParRegions.cpp
+++ b/src/ParallelizationRegions/ParRegions.cpp
@@ -24,6 +24,7 @@ using std::make_pair;
 using std::map;
 using std::set;
 using std::wstring;
+using std::tuple;

 extern void createMapLoopGraph(map<int, LoopGraph*> &sortedLoopGraph, const vector<LoopGraph*> *loopGraph);

@@ -954,4 +955,65 @@ void calculateLinesOfCode(vector<ParallelRegion*> &allRegions)

        __spf_print(1, "  Count of lines in region '%s' = %d\n", elem->GetName().c_str(), lineCounter);
    }
+}
+
+void propagateRegionInfo(map<tuple<int, string, string>, pair<DIST::Array*, DIST::ArrayAccessInfo*>>& declaredArrays,
+                         const map<DIST::Array*, set<DIST::Array*>>& arrayLinksByFuncCalls,
+                         const vector<ParallelRegion*> &parallelRegions)
+{
+    bool modified = true;
+    while (modified)
+    {
+        modified = false;
+        
+        for (auto &array_pair: declaredArrays)
+        {
+            auto array = array_pair.second.first;
+            if (array->GetLocation().first == DIST::l_PARAMETER)
+            {
+                set<DIST::Array*> realArrayRef;
+                getAllArrayRefs(array, array, realArrayRef, arrayLinksByFuncCalls);
+
+                auto regs = array->GetRegionsName();
+                for (auto& ref : realArrayRef)
+                {
+                    auto regsRef = ref->GetRegionsName();
+                    for (auto& reg : regsRef)
+                    {
+                        if (regs.count(reg) == 0)
+                        {
+                            array->SetRegionPlace(reg);
+                            modified = true;
+                        }
+                    }
+
+                }
+            }
+        }
+    }
+
+    bool hasNonDefaultReg = false;
+    for (auto& elem : parallelRegions)
+    {
+        string regName = elem->GetName();
+        convertToLower(regName);
+        if (regName != "default")
+            hasNonDefaultReg = true;
+    }
+
+    if (hasNonDefaultReg)
+    {
+        for (auto array : declaredArrays)
+        {
+            if (array.second.first->GetRegionsName().size() == 0)
+                array.second.first->SetDistributeFlag(DIST::NO_DISTR);
+            else if (array.second.first->GetRegionsName().size() == 1)
+            {
+                string regName = *array.second.first->GetRegionsName().begin();
+                convertToLower(regName);
+                if (regName == "default")
+                    array.second.first->SetDistributeFlag(DIST::NO_DISTR);
+            }
+        }
+    }
 }
--- a/src/ParallelizationRegions/ParRegions_func.h
+++ b/src/ParallelizationRegions/ParRegions_func.h
@@ -10,3 +10,7 @@ int printParalleRegions(const char *fileName, std::vector<ParallelRegion*> &regi
 bool buildGraphFromUserDirectives(const std::vector<Statement*> &userDvmAlignDirs, DIST::GraphCSR<int, double, attrType> &G, DIST::Arrays<int> &allArrays, const std::map<DIST::Array*, std::set<DIST::Array*>> &arrayLinksByFuncCalls, const std::set<DIST::Array*>& alignedArrays, std::set<DIST::Array*>& addedArrays, const std::map<std::string, std::vector<FuncInfo*>>& funcsByFile);
 void clearRegionStaticData();
 void calculateLinesOfCode(std::vector<ParallelRegion*> &allRegions);
+
+void propagateRegionInfo(std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>>& declaredArrays,
+                         const std::map<DIST::Array*, std::set<DIST::Array*>>& arrayLinksByFuncCall,
+                         const std::vector<ParallelRegion*>& parallelRegions);
--- a/src/ParallelizationRegions/merge_regions.cpp
+++ b/src/ParallelizationRegions/merge_regions.cpp
@@ -0,0 +1,624 @@
+#include "leak_detector.h"
+
+#include <set>
+#include <map>
+#include "merge_regions.h"
+
+using std::map;
+using std::set;
+using std::pair;
+using std::string;
+using std::vector;
+
+//TODO: need to create new clause!!
+static void parseMergeDirective(const char *comment,
+                                vector<pair<string, string>> &parsed_mapping)
+{
+    while (comment)
+    {
+        auto *line_end = strchr(comment, '\n');
+
+        static const char prefix[] = "!!spf transform(merge_arrays(";
+        static const auto compare_chars = sizeof(prefix) - 1;
+
+        if (strlen(comment) >= compare_chars)
+        {
+            std::string comment_cmp(comment, compare_chars);
+            convertToLower(comment_cmp);
+
+            if (comment_cmp == prefix)
+            {
+                auto* pair_start = comment + compare_chars;
+                auto* comma = strchr(pair_start, ',');
+                if (comma)
+                {
+                    auto* close_br = strchr(comma + 1, ')');
+                    if (close_br)
+                    {
+                        parsed_mapping.emplace_back(
+                            string(pair_start, comma - pair_start),
+                            string(comma + 1, close_br - comma - 1));
+                    }
+                }
+            }
+        }
+
+        comment = line_end;
+
+        if (comment)
+            comment++;
+    }
+}
+
+static string getNonDefaultRegion(DIST::Array *a)
+{
+    string result;
+
+    if (!a)
+        return result;
+
+    for (const auto &reg_name : a->GetRegionsName())
+    {
+        if (reg_name != "default")
+        {
+            if (!result.empty())
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            result = reg_name;
+        }
+    }
+
+    return result;
+}
+
+static bool hasSameSizes(DIST::Array *a, DIST::Array *b)
+{
+    for (auto *array : {a, b})
+    {
+        for (const auto &p : array->GetSizes())
+        {
+            if (p.first < 0 || p.second < 0)
+                return false;
+        }
+    }
+
+    return a->GetSizes() == b->GetSizes() && a->GetTypeSize() == b->GetTypeSize();
+}
+
+static bool checkSimilarTemplates(vector<ParallelRegion *> &regions,
+                                  const map<string, string> &new_region_mapping)
+{
+    // new region -> old regions
+    map<string, set<string>> new_region_inverse_mapping;
+    for (const auto &p : new_region_mapping)
+        new_region_inverse_mapping[p.second].insert(p.first);
+
+    for (const auto &new_reg : new_region_inverse_mapping)
+    {
+        DIST::Array *template_array = nullptr;
+        string first_reg_name;
+
+        for (const auto &old_region_name : new_reg.second)
+        {
+            auto *old_reg = getRegionByName(regions, old_region_name);
+
+            if (!old_reg)
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            const auto &distr_rules = old_reg->GetDataDir().GetDistrRules();
+            if (distr_rules.size() != 1)
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            auto *current_template = distr_rules.front().first;
+
+            if (template_array)
+            {
+                if (!hasSameSizes(template_array, current_template))
+                {
+                    __spf_print(1, "Templates of %s and %s has different sizes\n",
+                                first_reg_name.c_str(),
+                                old_region_name.c_str());
+
+                    return false;
+                }
+                // else everything OK
+            }
+            else
+            {
+                template_array = current_template;
+                first_reg_name = old_region_name;
+            }
+        }
+    }
+
+    return true;
+}
+
+static bool hasSameAlignment(const std::set<const AlignRule *> &align_a,
+                             const std::set<const AlignRule *> &align_b)
+{
+    if (align_a.size() != 1 || align_b.size() != 1)
+        return false;
+
+    const auto *rule_a = *align_a.begin();
+    const auto *rule_b = *align_b.begin();
+
+    if (rule_a->alignRule != rule_b->alignRule)
+        return false;
+
+    return true;
+}
+
+static void printExpr(SgExpression *e, string pad)
+{
+    if (!e)
+        return;
+
+    __spf_print(1, "%s%d: %s\n", pad.c_str(), e->variant(), e->unparse());
+
+    printExpr(e->lhs(), pad + "  ");
+    printExpr(e->rhs(), pad + "  ");
+}
+
+static pair<vector<SgStatement *>, SgSymbol *> generateDeclaration(const string &array_name, const string &common_block_name,
+                                                                   const vector<pair<int, int>> &sizes, SgType *type, SgStatement *scope)
+{
+    auto *array_symbol = new SgSymbol(VARIABLE_NAME, array_name.c_str(), new SgType(T_ARRAY), scope);
+
+    auto *decl = new SgDeclarationStatement(VAR_DECL);
+
+    decl->setExpression(1, new SgTypeExp(*type));
+
+    SgExpression *subs = new SgExprListExp();
+
+    auto *array_ref = new SgArrayRefExp(*array_symbol, *subs);
+
+    for (int i = 0; i < sizes.size(); i++)
+    {
+        const auto &p = sizes[i];
+        auto *d = new SgExpression(DDOT, new SgValueExp(p.first), new SgValueExp(p.second));
+        subs->setLhs(d);
+
+        if (i + 1 < sizes.size())
+        {
+            subs->setRhs(new SgExprListExp());
+            subs = subs->rhs();
+        }
+    }
+
+    decl->setExpression(0, array_ref);
+
+    auto comm = new SgStatement(COMM_STAT);
+
+    comm->setExpression(0, new SgExpression(COMM_LIST,
+                                            new SgVarRefExp(array_symbol),
+                                            NULL,
+                                            new SgSymbol(COMMON_NAME, common_block_name.c_str())));
+
+    return {{decl, comm}, array_symbol};
+}
+
+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;
+}
+
+SgType* GetArrayType(DIST::Array *array)
+{
+    if (!array)
+        return NULL;
+
+    for (const auto& decl_place : array->GetDeclInfo())
+    {
+        if (SgFile::switchToFile(decl_place.first) != -1)
+        {
+            auto* decl = SgStatement::getStatementByFileAndLine(decl_place.first, decl_place.second);
+            if (decl)
+            {
+                for (int i = 0; i < 3; i++)
+                {
+                    auto* found_type = isSgTypeExp(findExprWithVariant(decl->expr(i), TYPE_OP));
+                    if (found_type)
+                        return found_type->type();
+                }
+            }
+        }
+    }
+
+    return NULL;
+}
+
+SgSymbol *insertDeclIfNeeded(const string &array_name,
+                             const string &common_block_name,
+                             DIST::Array *example_array,
+                             FuncInfo *dest,
+                             map<FuncInfo *, map<string, SgSymbol *>> &inserted_arrays)
+{
+    auto *type = GetArrayType(example_array);
+
+    if (!type)
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    if (SgFile::switchToFile(dest->fileName) == -1)
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    auto &by_func = inserted_arrays[dest];
+    auto it = by_func.find(array_name);
+
+    if (it != by_func.end())
+        return it->second;
+
+    SgStatement *st = dest->funcPointer;
+
+    auto *end = st->lastNodeOfStmt();
+
+    st = st->lexNext();
+
+    while (st != end && !isSgExecutableStatement(st))
+    {
+        st = st->lexNext();
+    }
+
+    auto generated = generateDeclaration(array_name, common_block_name,
+                                         example_array->GetSizes(),
+                                         type, dest->funcPointer);
+    for (auto *new_stmt : generated.first)
+        st->insertStmtBefore(*new_stmt, *dest->funcPointer);
+
+    by_func[array_name] = generated.second;
+
+    return generated.second;
+}
+
+static pair<string, string> createNewArray(DIST::Array *example_array, const string &base_name,
+                                           const map<string, vector<FuncInfo *>> &allFuncInfo,
+                                           map<FuncInfo *, map<string, SgSymbol *>> &inserted_arrays)
+{
+    auto common_block_name = base_name + "_merge_r";
+    auto array_name = base_name;
+
+    for (const auto &by_file : allFuncInfo)
+    {
+        for (auto *func_info : by_file.second)
+        {
+            if (func_info->isMain)
+            {
+                insertDeclIfNeeded(
+                    array_name,
+                    common_block_name,
+                    example_array,
+                    func_info,
+                    inserted_arrays);
+            }
+        }
+    }
+
+    return std::make_pair(array_name, common_block_name);
+}
+
+static void replaceArrayRec(SgExpression *e,
+                            const set<string> &arrays_to_replace,
+                            SgSymbol **func_symbol_hint,
+                            const pair<string, string> &replace_by,
+                            DIST::Array *example_array,
+                            FuncInfo *func,
+                            map<FuncInfo *, map<string, SgSymbol *>> &inserted_arrays)
+{
+    if (!e)
+        return;
+
+    if (isArrayRef(e) && arrays_to_replace.find(e->symbol()->identifier()) != arrays_to_replace.end())
+    {
+        if (!(*func_symbol_hint))
+        {
+            *func_symbol_hint = insertDeclIfNeeded(
+                replace_by.first, replace_by.second,
+                example_array,
+                func,
+                inserted_arrays);
+        }
+
+        e->setSymbol(*func_symbol_hint);
+    }
+
+    replaceArrayRec(
+        e->lhs(),
+        arrays_to_replace,
+        func_symbol_hint,
+        replace_by,
+        example_array,
+        func,
+        inserted_arrays);
+
+    replaceArrayRec(
+        e->rhs(),
+        arrays_to_replace,
+        func_symbol_hint,
+        replace_by,
+        example_array,
+        func,
+        inserted_arrays);
+}
+
+static void replaceRegion(SgStatement* st, const map<string, string> &new_region_mapping)
+{
+    if (!st)
+        return;
+
+    if(isSPF_stat(st) && st->variant() == SPF_PARALLEL_REG_DIR)
+    {
+        auto it = new_region_mapping.find(st->symbol()->identifier());
+
+        if (it != new_region_mapping.end())
+            st->setSymbol(*(new SgSymbol(CONST_NAME, it->second.c_str())));
+    }
+}
+
+void mergeRegions(vector<ParallelRegion *> &regions, const map<string, vector<FuncInfo *>> &allFuncInfo)
+{
+    for (const auto *region : regions)
+    {
+        __spf_print(1, "region %s\n", region->GetName().c_str());
+
+        const auto &dirs = region->GetDataDir();
+
+        __spf_print(1, "  distr rules: %d\n", dirs.distrRules.size());
+
+        const auto &currentVariant = region->GetCurrentVariant();
+
+        int distr_idx = 0;
+        for (const auto &distr : dirs.distrRules)
+        {
+            const auto &dist_rule = distr.second.back().distRule;
+
+            string sizes;
+            for (const auto &p : distr.first->GetSizes())
+            {
+                if (!sizes.empty())
+                    sizes.push_back(',');
+
+                sizes += std::to_string(p.first) + ":" + std::to_string(p.second);
+            }
+
+            __spf_print(1, "      DIST %s(%s)", distr.first->GetName().c_str(), sizes.c_str());
+            for (const auto &dim : dist_rule)
+                __spf_print(1, " %c", dim == dist::BLOCK ? 'B' : '*');
+
+            __spf_print(1, "\n");
+            distr_idx++;
+        }
+
+        __spf_print(1, "  align rules: %d\n", dirs.alignRules.size());
+
+        for (const auto &align : dirs.alignRules)
+        {
+            string sub_a, sub_b;
+
+            int i = 0;
+            for (const auto coefs : align.alignRule)
+            {
+                if (!sub_a.empty())
+                    sub_a.push_back(',');
+
+                sub_a += std::to_string(coefs.first) + "*i" +
+                         std::to_string(i) + "+" + std::to_string(coefs.second);
+
+                i++;
+            }
+
+            for (const auto coefs : align.alignRuleWith)
+            {
+                if (!sub_b.empty())
+                    sub_b.push_back(',');
+
+                sub_b += std::to_string(coefs.second.first) + "*i" +
+                         std::to_string(coefs.first) + "+" + std::to_string(coefs.second.second);
+            }
+
+            __spf_print(1, "      ALIGN %s(%s) WITH %s(%s)\n",
+                        align.alignArray->GetName().c_str(), sub_a.c_str(),
+                        align.alignWith->GetName().c_str(), sub_b.c_str());
+        }
+    }
+
+    // parse directives
+
+    // new array name -> current arrays
+    map<string, set<DIST::Array *>> arrays_to_merge;
+    map<DIST::Array *, set<const AlignRule *>> array_alignment;
+
+    for (const auto &by_file : allFuncInfo)
+    {
+        const auto current_file_name = by_file.first;
+
+        if (SgFile::switchToFile(current_file_name) == -1)
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+        for (auto *func_info : by_file.second)
+        {
+            SgStatement *curr_stmt = func_info->funcPointer;
+            if (!curr_stmt)
+                continue;
+
+            auto *stmt_end = curr_stmt->lastDeclaration();
+            if (!stmt_end)
+                continue;
+
+            stmt_end = stmt_end->lexNext();
+
+            for (; curr_stmt && curr_stmt != stmt_end; curr_stmt = curr_stmt->lexNext())
+            {
+                if (curr_stmt->comments())
+                {
+                    vector<pair<string, string>> parsed_mapping;
+                    parseMergeDirective(curr_stmt->comments(), parsed_mapping);
+
+                    for (const auto &p : parsed_mapping)
+                    {
+                        auto *found_array = getArrayFromDeclarated(curr_stmt, p.first);
+                        if (found_array)
+                        {
+                            arrays_to_merge[p.second].insert(found_array);
+                            array_alignment[found_array] = {};
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // find alignment rules for array
+
+    for (const auto *region : regions)
+    {
+        const auto &dirs = region->GetDataDir();
+
+        for (const auto &align : dirs.alignRules)
+        {
+            auto it = array_alignment.find(align.alignArray);
+
+            if (it != array_alignment.end())
+                it->second.insert(&align);
+        }
+    }
+
+    // old region -> new region
+    map<string, string> new_region_mapping;
+
+    // new array -> new region
+    map<string, string> arrays_new_region_mapping;
+    vector<string> created_region_names;
+
+    for (const auto &by_new_array : arrays_to_merge)
+    {
+        string new_region_name;
+        for (auto *current_array : by_new_array.second)
+        {
+            auto current_array_region = getNonDefaultRegion(current_array);
+            auto it = new_region_mapping.find(current_array_region);
+            if (it != new_region_mapping.end())
+            {
+                if (new_region_name.empty())
+                    new_region_name = it->second;
+                else if (new_region_name != it->second)
+                    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+            }
+        }
+
+        if (new_region_name.empty())
+        {
+            new_region_name = "merged_reg_" + std::to_string(created_region_names.size());
+            created_region_names.push_back(new_region_name);
+        }
+
+        for (auto *current_array : by_new_array.second)
+        {
+            auto current_array_region = getNonDefaultRegion(current_array);
+            new_region_mapping[current_array_region] = new_region_name;
+        }
+
+        arrays_new_region_mapping[by_new_array.first] = new_region_name;
+    }
+
+    if (!checkSimilarTemplates(regions, new_region_mapping))
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    map<FuncInfo *, map<string, SgSymbol *>> inserted_arrays;
+
+    for (const auto &by_dest_array : arrays_to_merge)
+    {
+        const auto &copy_arrays = by_dest_array.second;
+
+        if (copy_arrays.empty())
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+        auto *first_element = *copy_arrays.begin();
+        auto first_elem_rules_it = array_alignment.find(first_element);
+
+        if (first_elem_rules_it == array_alignment.end())
+            continue;
+
+        const auto &first_elem_rules = first_elem_rules_it->second;
+
+        for (auto *array_to_merge : copy_arrays)
+        {
+            auto array_rules_it = array_alignment.find(array_to_merge);
+
+            if (array_rules_it == array_alignment.end())
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            const auto &array_rules = array_rules_it->second;
+
+            if (!hasSameSizes(array_to_merge, first_element) || !hasSameAlignment(first_elem_rules, array_rules))
+            {
+                __spf_print(1, "Arrays %s and %s has different sizes or align rules\n",
+                            array_to_merge->GetName().c_str(),
+                            first_element->GetName().c_str());
+
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+            }
+        }
+
+        __spf_print(1, "merge into %s (%s):\n", by_dest_array.first.c_str(), arrays_new_region_mapping[by_dest_array.first].c_str());
+        for (auto *array_to_merge : copy_arrays)
+            __spf_print(1, "%s\n", array_to_merge->GetName().c_str());
+
+        auto created_array_info = createNewArray(first_element, by_dest_array.first, allFuncInfo, inserted_arrays);
+
+        set<string> arrays_to_replace;
+        for (auto *array_to_merge : copy_arrays)
+            arrays_to_replace.insert(array_to_merge->GetShortName());
+
+        for (const auto &by_file : allFuncInfo)
+        {
+            if (SgFile::switchToFile(by_file.first) == -1)
+                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+            for (auto *func_info : by_file.second)
+            {
+                SgSymbol *func_symbol_hint = nullptr;
+                SgStatement *st = func_info->funcPointer;
+
+                auto *func_end = st->lastNodeOfStmt();
+
+                st = st->lexNext();
+
+                while (st && !isSgExecutableStatement(st) && st != func_end)
+                    st = st->lexNext();
+
+                while (st && st != func_end)
+                {
+                    for (int i = 0; i < 3; i++)
+                    {
+                        replaceArrayRec(
+                            st->expr(i),
+                            arrays_to_replace,
+                            &func_symbol_hint,
+                            created_array_info,
+                            first_element,
+                            func_info,
+                            inserted_arrays);
+                    }
+
+                    replaceRegion(st, new_region_mapping);
+
+                    st = st->lexNext();
+                }
+            }
+        }
+    }
+}
--- a/src/ParallelizationRegions/merge_regions.h
+++ b/src/ParallelizationRegions/merge_regions.h
@@ -0,0 +1,8 @@
+#include "../GraphCall/graph_calls.h"
+#include "ParRegions.h"
+
+#include <string>
+#include <vector>
+#include <map>
+
+void mergeRegions(std::vector<ParallelRegion*> &regions, const std::map<std::string, std::vector<FuncInfo*>> &allFuncInfo);
--- a/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp
+++ b/src/ParallelizationRegions/resolve_par_reg_conflicts.cpp
@@ -19,6 +19,7 @@
 #include "SgUtils.h"
 #include "expr_transform.h"
 #include "FunctionPurifying/function_purifying.h"
+#include "uniq_name_creator.h"

 using std::map;
 using std::pair;
@@ -71,7 +72,7 @@ static bool isSPF_reg(SgStatement *st)
    return st->variant() == SPF_PARALLEL_REG_DIR || st->variant() == SPF_END_PARALLEL_REG_DIR;
 }

-static const vector<const Variable*> getArraySynonyms(DIST::Array *array)
+const vector<const Variable*> getArraySynonyms(DIST::Array *array)
 {
    auto arrayBlock = allUsedCommonArrays.find(array);
    if (arrayBlock == allUsedCommonArrays.end())
@@ -127,15 +128,16 @@ static string getStringDeclaration(SgSymbol *symb)
    return decl;
 }

-static void insertStringDeclarations(SgStatement *insertPlace, DIST::Array *array)
+static void insertStringDeclarations(SgStatement *insertPlace, DIST::Array *array, UniqueNameCreator& unique_name_creator)
 {
    auto varsOnPos = getArraySynonyms(array);
    if (varsOnPos.size() && varsOnPos[0]->getName() == array->GetShortName())
    {
+        string newArrName, commName;
+        unique_name_creator.GetUniqueName(array, newArrName, commName);
        SgSymbol *varSymb = varsOnPos[0]->getSymbol();
        string varName = varSymb->identifier();
-        string newName = varName + "_c";
-        varSymb->changeName(newName.c_str());
+        varSymb->changeName(newArrName.c_str());
        string decl = getStringDeclaration(varsOnPos[0]->getSymbol());
        varSymb->changeName(varName.c_str());
        insertPlace->addComment(decl.c_str());
@@ -662,12 +664,11 @@ static void replaceFuncCalls(const ParallelRegionLines &lines, const map<string,
 static map<string, map<DIST::Array*, SgStatement*>> createdCommonBlocks; // file -> array -> new common statement
 static map<string, map<DIST::Array*, pair<SgSymbol*, SgSymbol*>>> createdCommonArrays; // file -> array -> (orig, copy)

-static SgStatement* createCommonBlock(SgFile *file, DIST::Array *array)
+static SgStatement* createCommonBlock(SgFile *file, DIST::Array *array, UniqueNameCreator& unique_name_creator)
 {
-    auto varsOnPos = getArraySynonyms(array);
-    if (!varsOnPos.size())
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+    string newArrName, commBlockName;

+    unique_name_creator.GetUniqueName(array, newArrName, commBlockName);
    string fileName = file->filename();

    if (SgFile::switchToFile(fileName) != -1)
@@ -683,7 +684,6 @@ static SgStatement* createCommonBlock(SgFile *file, DIST::Array *array)
            // creating new common-block statement
            //TODO: consistence with declaration
            //string commBlockName = checkSymbNameAndCorrect(array->GetShortName() + "_r");
-            string commBlockName = array->GetShortName() + "_r";
            SgStatement *commDecl = new SgStatement(COMM_STAT);

            SgSymbol *commSymb = new SgSymbol(VARIABLE_NAME, commBlockName.c_str());
@@ -705,7 +705,6 @@ static SgStatement* createCommonBlock(SgFile *file, DIST::Array *array)
            {
                //TODO: consistence with declaration
                //string newArrName = checkSymbNameAndCorrect(varsOnPos[0]->getName() + "_c");
-                string newArrName = varsOnPos[0]->getName() + "_c";

                newArrSymb = new SgSymbol(VARIABLE_NAME, newArrName.c_str(), file->firstStatement());
                SgType *type = new SgType(T_ARRAY);
@@ -751,7 +750,7 @@ static SgStatement* createCommonBlock(SgFile *file, DIST::Array *array)
 // func -> arrays; funcs where new common statement inserted
 static map<FuncInfo*, set<DIST::Array*>> insertedCommonBlocks;

-static void insertCommonBlock(FuncInfo *func, DIST::Array *array)
+static void insertCommonBlock(FuncInfo *func, DIST::Array *array, UniqueNameCreator& unique_name_creator)
 {
    SgFile *file = func->funcPointer->GetOriginal()->getFile();
    SgStatement *insertPlace = NULL;
@@ -767,7 +766,7 @@ static void insertCommonBlock(FuncInfo *func, DIST::Array *array)
    if (!insertPlace)
        insertPlace = func->funcPointer->GetOriginal();

-    SgStatement *commDecl = createCommonBlock(file, array);
+    SgStatement *commDecl = createCommonBlock(file, array, unique_name_creator);
    SgStatement *copyDecl = commDecl->copyPtr();

    auto st = insertPlace->controlParent();
@@ -779,7 +778,7 @@ static void insertCommonBlock(FuncInfo *func, DIST::Array *array)
    insertPlace->lexNext()->setlineNumber(nextLine);

    // create declaration via comment
-    insertStringDeclarations(insertPlace->lexNext(), array);
+    insertStringDeclarations(insertPlace->lexNext(), array, unique_name_creator);
 }

 // file -> lines -> arrays; lines where arrays copying is inserted
@@ -1097,6 +1096,7 @@ pair<SgSymbol*, SgSymbol*> copyArray(const pair<string, int> &place,
 static void copyFunction(ParallelRegion *region,
                         FuncInfo *func,
                         const map<string, FuncInfo*> &funcMap,
+                         UniqueNameCreator& unique_name_creator,
                         const string &suffix = "")
 {
    if (SgFile::switchToFile(func->fileName) != -1)
@@ -1146,14 +1146,14 @@ static void copyFunction(ParallelRegion *region,
            if (origStat->variant() == COMM_STAT)
            {
                for (auto &arrayBlock : allUsedCommonArrays)
-                    createCommonBlock(file, arrayBlock.first);
+                    createCommonBlock(file, arrayBlock.first, unique_name_creator);

                auto usedCommonArrays = region->GetUsedCommonArrays().find(func);
                if (usedCommonArrays != region->GetUsedCommonArrays().end())
                {
                    for (auto &arrayLines : usedCommonArrays->second)
                    {
-                        SgStatement *commDecl = createCommonBlock(file, arrayLines.first);
+                        SgStatement *commDecl = createCommonBlock(file, arrayLines.first, unique_name_creator);
                        SgStatement *copyDecl = commDecl->copyPtr();

                        while (!isSgExecutableStatement(copyStat) || isSPF_stat(copyStat))
@@ -1163,7 +1163,7 @@ static void copyFunction(ParallelRegion *region,
                        copyStat->insertStmtAfter(*copyDecl, *copyStat->controlParent());

                        // making declaration of new common array symbol via comment through files
-                        insertStringDeclarations(copyStat->lexNext(), arrayLines.first);
+                        insertStringDeclarations(copyStat->lexNext(), arrayLines.first, unique_name_creator);
                    }

                    auto it = createdCommonArrays.find(file->filename());
@@ -1619,6 +1619,8 @@ int resolveParRegions(vector<ParallelRegion*> &regions, const map<string, vector
    map<string, FuncInfo*> funcMap;
    createMapOfFunc(allFuncInfo, funcMap);

+    UniqueNameCreator unique_name_creator(allFuncInfo);
+
    if (sharedMemoryParallelization == 0)
    {
        map<string, map<int, set<string>>> copied;
@@ -1688,7 +1690,7 @@ int resolveParRegions(vector<ParallelRegion*> &regions, const map<string, vector
                                if (itt == it->second.end() && arrayBlock.first->GetShortName() == varsOnPos[0]->getName())
                                {
                                    // need to insert common-block
-                                    insertCommonBlock(func, arrayBlock.first);
+                                    insertCommonBlock(func, arrayBlock.first, unique_name_creator);
                                    it->second.insert(arrayBlock.first);
                                }
                            }
@@ -1781,7 +1783,7 @@ int resolveParRegions(vector<ParallelRegion*> &regions, const map<string, vector
                        if (itt == it->second.end() && arrayBlock.first->GetShortName() == varsOnPos[0]->getName())
                        {
                            // need to insert common-block
-                            insertCommonBlock(func, arrayBlock.first);
+                            insertCommonBlock(func, arrayBlock.first, unique_name_creator);
                            it->second.insert(arrayBlock.first);
                        }
                    }
@@ -1813,7 +1815,7 @@ int resolveParRegions(vector<ParallelRegion*> &regions, const map<string, vector
                    if (usedCommonArrays != region->GetUsedCommonArrays().end())
                    {
                        for (auto &arrayBlock : allUsedCommonArrays)
-                            createCommonBlock(file, arrayBlock.first);
+                            createCommonBlock(file, arrayBlock.first, unique_name_creator);

                        auto it = insertedCommonBlocks.find(func);
                        if (it == insertedCommonBlocks.end())
@@ -1825,7 +1827,7 @@ int resolveParRegions(vector<ParallelRegion*> &regions, const map<string, vector
                            if (itt == it->second.end())
                            {
                                // need to insert common-block
-                                insertCommonBlock(func, arrayLines.first);
+                                insertCommonBlock(func, arrayLines.first, unique_name_creator);
                                it->second.insert(arrayLines.first);

                                // replace common arrays to new common arrays in executable code section
@@ -1858,7 +1860,7 @@ int resolveParRegions(vector<ParallelRegion*> &regions, const map<string, vector
                    // need copy function for every region, the exeption is defalut region
                    for (auto &regionId : func->callRegions)
                        if (regionId)
-                            copyFunction(getRegionById(regions, regionId), func, funcMap, string("_r") + to_string(regionId));
+                            copyFunction(getRegionById(regions, regionId), func, funcMap, unique_name_creator, string("_r") + to_string(regionId));
                }
            }
        }
--- a/src/ParallelizationRegions/resolve_par_reg_conflicts.h
+++ b/src/ParallelizationRegions/resolve_par_reg_conflicts.h
@@ -21,4 +21,6 @@ std::pair<SgSymbol*, SgSymbol*> copyArray(const std::pair<std::string, int>& pla
                                          const std::string& suffix,
                                          std::string& filename,
                                          std::map<std::string, std::map<int, std::set<std::string>>>& newDeclsToInclude,
-                                          std::map<std::string, std::map<int, std::set<std::string>>>& copied);
+                                          std::map<std::string, std::map<int, std::set<std::string>>>& copied);
+
+const std::vector<const Variable*> getArraySynonyms(DIST::Array* array);
--- a/src/ParallelizationRegions/uniq_name_creator.cpp
+++ b/src/ParallelizationRegions/uniq_name_creator.cpp
@@ -0,0 +1,98 @@
+#include "leak_detector.h"
+
+#include <set>
+#include <map>
+#include <string>
+
+#include "SgUtils.h"
+#include "uniq_name_creator.h"
+#include "resolve_par_reg_conflicts.h"
+
+using namespace::std;
+
+static const string COMMON_ARRAY_SUFFIX = "_c";
+static const string COMMON_BLOCK_SUFFIX = "_r";
+
+void UniqueNameCreator::GetSymbolsRec(SgExpression* exp, set<string>& add_to)
+{
+    if (!exp)
+        return;
+
+    if (isArrayRef(exp) && exp->symbol() && exp->symbol()->identifier())
+        add_to.emplace(exp->symbol()->identifier());
+
+    GetSymbolsRec(exp->lhs(), add_to);
+    GetSymbolsRec(exp->rhs(), add_to);
+}
+
+void UniqueNameCreator::FillDeclarations()
+{
+    allDeclarations.clear();
+    auto* file_before = current_file;
+
+    for (const auto& by_file : funcInfo)
+    {
+        if (SgFile::switchToFile(by_file.first) != -1)
+        {
+            for (const auto* by_func : by_file.second)
+            {
+                SgStatement* st = by_func->funcPointer;
+
+                if (st)
+                    st = st->lexNext();
+
+                while (st)
+                {
+                    for (int i = 0; i < 3; i++)
+                        GetSymbolsRec(st->expr(i), allDeclarations);
+
+                    st = st->lexNext();
+                }
+            }
+        }
+        else
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+    }
+
+    SgFile::switchToFile(file_before->filename());
+    declarationsAnalyzed = true;
+}
+
+void UniqueNameCreator::GetUniqueName(DIST::Array* array, string& array_name, string& common_block_name)
+{
+    auto varsOnPos = getArraySynonyms(array);
+    if (!varsOnPos.size())
+        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+    auto array_plain_name = varsOnPos[0]->getName();
+
+    auto it = generatedNames.find(array);
+    if (it != generatedNames.end())
+    {
+        array_name.assign(it->second.first);
+        common_block_name.assign(it->second.second);
+        return;
+    }
+
+    if (!declarationsAnalyzed)
+        FillDeclarations();
+
+    int v = 1;
+    auto created_array_name = array_plain_name + COMMON_ARRAY_SUFFIX;
+    auto created_common_name = array_plain_name + COMMON_BLOCK_SUFFIX;
+
+    while (allDeclarations.find(created_array_name) != allDeclarations.end() ||
+        allDeclarations.find(created_common_name) != allDeclarations.end())
+    {
+        created_array_name = array_plain_name + "_v" + std::to_string(v) + COMMON_ARRAY_SUFFIX;
+        created_common_name = array_plain_name + "_v" + std::to_string(v) + COMMON_BLOCK_SUFFIX;
+        v++;
+    }
+
+    allDeclarations.insert(created_array_name);
+    allDeclarations.insert(created_common_name);
+    generatedNames.emplace(array, std::make_pair(created_array_name, created_common_name));
+
+    array_name.assign(created_array_name);
+    common_block_name.assign(created_common_name);
+}
--- a/src/ParallelizationRegions/uniq_name_creator.h
+++ b/src/ParallelizationRegions/uniq_name_creator.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <map>
+#include <set>
+#include <string>
+#include "GraphCall/graph_calls.h"
+
+class UniqueNameCreator
+{
+    std::map<std::string, std::vector<FuncInfo*>> funcInfo;
+    std::set<std::string> allDeclarations;
+    bool declarationsAnalyzed = false;
+    std::map<const DIST::Array*, std::pair<std::string, std::string>> generatedNames;
+
+    static void GetSymbolsRec(SgExpression* exp, std::set<std::string>& add_to);
+    void FillDeclarations();
+
+public:
+    UniqueNameCreator(const std::map<std::string, std::vector<FuncInfo*>>& allFuncInfo)
+    {
+        declarationsAnalyzed = false;
+        funcInfo = allFuncInfo;
+    }
+
+    void GetUniqueName(DIST::Array* array, std::string& array_name, std::string& common_block_name);
+};
--- a/src/PrivateAnalyzer/private_arrays_search.cpp
+++ b/src/PrivateAnalyzer/private_arrays_search.cpp
@@ -1,3 +1,4 @@
+#include <algorithm>
 #include <map>
 #include <unordered_set>
 #include <unordered_map>
@@ -6,16 +7,26 @@
 #include <numeric>
 #include <iostream>

+#include "ArrayConstantPropagation/propagation.h"
+#include "CFGraph/CFGraph.h"
+#include "Distribution/Array.h"
+#include "graph_loops.h"
 #include "private_arrays_search.h"
 #include "range_structures.h"
 #include "region.h"
 #include "SgUtils.h"
-#include "graph_loops.h"
-#include "CFGraph/CFGraph.h"
 #include "utils.h"
+#include "Utils/AstWrapper.h"

 using namespace std;

+extern std::map<std::tuple<int, std::string, std::string>, std::pair<DIST::Array*, DIST::ArrayAccessInfo*>> declaredArrays;
+
+extern unordered_set<SgStatement*> statementsToRemove;
+extern unordered_map<string, vector<pair<SgStatement*, SgStatement*>>> expToChange;
+
+static unordered_set<Region*> collapsed;
+
 static void RemoveEmptyPoints(ArrayAccessingIndexes& container)
 {
    ArrayAccessingIndexes resultContainer;
@@ -30,10 +41,9 @@ static void RemoveEmptyPoints(ArrayAccessingIndexes& container)
                points.push_back(arrayPoint);
        }

-        if (points.size() < accessingSet.GetElements().size() && !points.empty())
+        if (!points.empty())
            resultContainer[arrayName] = points;
-
-        if (points.empty())
+        else
            toRemove.insert(arrayName);
    }

@@ -49,41 +59,81 @@ static void Collapse(Region* region)
    if (region->getBasickBlocks().empty())
        return;

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

-    for (auto& byBlock : region->getBasickBlocks()) 
-    {
-        for (auto& [arrayName, arrayRanges] : byBlock->array_use)
-        {
-            AccessingSet diff = byBlock->array_use[arrayName].Diff(byBlock->array_in[arrayName]);
-            region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
-        }
-    }
+    RegionInstruction instruction;
+    instruction.def = move(region->array_def);
+

-    ArrayAccessingIndexes useUnion;
    for (auto& byBlock : region->getBasickBlocks())
-        for (auto& [arrayName, arrayRanges] : byBlock->array_use)
-            useUnion[arrayName] = useUnion[arrayName].Union(byBlock->array_use[arrayName]);
+    {
+        for (auto& instruction : byBlock->instructions)
+        {
+            for (auto& [arrayName, _] : instruction.use)
+            {
+                AccessingSet diff = instruction.use[arrayName].Diff(instruction.in[arrayName]);
+                region->array_use[arrayName] = region->array_use[arrayName].Union(diff);
+            }
+        }
+    }

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

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

                for (const auto& [arrayName, accessSet] : prevBlock->array_out)
                {
                    if (newIn.find(arrayName) != newIn.end())
-                        newIn[arrayName] = newIn[arrayName].Intersect(accessSet);                    
+                        newIn[arrayName] = newIn[arrayName].Intersect(accessSet);
                    else
                        newIn[arrayName] = AccessingSet();
                }
@@ -117,7 +167,7 @@ static void SolveDataFlowIteratively(Region* DFG)
        b->array_in = move(newIn);
        ArrayAccessingIndexes newOut;

-        if (b->array_def.empty())        
+        if (b->array_def.empty())
            newOut = b->array_in;
        else if (b->array_in.empty())
            newOut = b->array_def;
@@ -133,25 +183,196 @@ static void SolveDataFlowIteratively(Region* DFG)
        }

        /* can not differ */
-        if (newOut != b->array_out) 
+        if (newOut != b->array_out)
            b->array_out = newOut;
        else
            worklist.erase(b);
-    } 
-    while (!worklist.empty());
+    } while (!worklist.empty());
+}
+
+static void SolveForBasickBlock(Region* block)
+{
+    ArrayAccessingIndexes newIn;
+    bool flagFirst = true;
+    for (Region* prevBlock : block->getPrevRegions())
+    {
+        if (flagFirst)
+        {
+            newIn = prevBlock->array_out;
+            flagFirst = false;
+        }
+        else
+        {
+            if (prevBlock->array_out.empty())
+            {
+                newIn.clear();
+                break;
+            }
+
+            for (const auto& [arrayName, accessSet] : prevBlock->array_out)
+            {
+                if (newIn.find(arrayName) != newIn.end())
+                    newIn[arrayName] = newIn[arrayName].Intersect(accessSet);
+                else
+                    newIn[arrayName] = AccessingSet();
+            }
+        }
+    }
+
+    if (block->instructions.empty())
+        block->instructions.push_back(RegionInstruction());
+
+    block->instructions[0].in = move(newIn);
+
+    for (int i = 0; i < block->instructions.size(); i++)
+    {
+        auto& instruction = block->instructions[i];
+
+        if (i > 0)
+            instruction.in = block->instructions[i - 1].out;
+
+        ArrayAccessingIndexes newOut;
+        if (instruction.def.empty())
+            newOut = instruction.in;
+        else if (instruction.in.empty())
+            newOut = instruction.def;
+        else
+        {
+            for (auto& [arrayName, accessSet] : instruction.def)
+            {
+                if (instruction.in.find(arrayName) != instruction.in.end())
+                    newOut[arrayName] = instruction.def[arrayName].Union(instruction.in[arrayName]);
+                else
+                    newOut[arrayName] = accessSet;
+            }
+            for (auto& [arrayName, accessSet] : instruction.in)
+            {
+                if (newOut.find(arrayName) == newOut.end())
+                {
+                    newOut[arrayName] = accessSet;
+                }
+            }
+        }
+
+        instruction.out = move(newOut);
+    }
+    if (!block->instructions.empty())
+        block->array_out = block->instructions.back().out;
+}
+
+static void SolveDataFlowTopologically(Region* DFG)
+{
+    for (Region* b : DFG->getBasickBlocks())
+    {
+        collapsed.insert(b);
+        SolveForBasickBlock(b);
+    }
 }

 static void SolveDataFlow(Region* DFG)
 {
    if (!DFG)
        return;
-
-    SolveDataFlowIteratively(DFG);
    for (Region* subRegion : DFG->getSubRegions())
+    {
        SolveDataFlow(subRegion);
+        DFG->addBasickBlocks(subRegion);
+    }
+    vector<Region*>& blocks = DFG->getBasickBlocks();
+    auto pos = remove_if(blocks.begin(), blocks.end(), [](Region* r) { return collapsed.find(r) != collapsed.end(); });
+    blocks.erase(pos, blocks.end());
+    TopologySort(DFG->getBasickBlocks(), DFG->getHeader());
+    SolveDataFlowTopologically(DFG);
    Collapse(DFG);
 }

+static bool getArrayDeclaredDimensions(SgArrayRefExp* arrayRef, vector<uint64_t>& declaredDims)
+{
+    if (!arrayRef || !arrayRef->symbol() || !isSgArrayType(arrayRef->symbol()->type()))
+        return false;
+    SgArrayType* arrayType = (SgArrayType*)arrayRef->symbol()->type();
+    int dimCount = arrayType->dimension();
+    for (int i = 0; i < dimCount; i++)
+    {
+        SgExpression* sizeExpr = arrayType->sizeInDim(i);
+        SgConstantSymb* constValSymb = isSgConstantSymb(sizeExpr->symbol());
+        SgSubscriptExp* subscriptExpr = isSgSubscriptExp(sizeExpr);
+        uint64_t dimLength;
+        if (sizeExpr && sizeExpr->variant() == INT_VAL)
+            dimLength = stol(sizeExpr->unparse());
+        else if (constValSymb)
+            dimLength = stol(constValSymb->constantValue()->unparse());
+        else if (subscriptExpr)
+        {
+            dimLength = stol(subscriptExpr->rhs()->unparse()) - stol(subscriptExpr->lhs()->unparse());
+        }
+        else
+            return false;
+
+        if (dimLength == 0)
+            return false;
+        declaredDims.push_back(dimLength);
+    }
+    return true;
+}
+
+static DIST::Array* getDistArrayBySymbol(SgSymbol* arrSym)
+{
+    if (!arrSym)
+        return nullptr;
+    for (auto& [key, val] : declaredArrays)
+    {
+        DIST::Array* distArr = val.first;
+        if (!distArr)
+            continue;
+        Symbol* declSym = distArr->GetDeclSymbol();
+        if (!declSym)
+            continue;
+        SgSymbol* sgDecl = declSym->GetOriginal();
+        if (sgDecl && isEqSymbols(sgDecl, arrSym))
+            return distArr;
+    }
+    return nullptr;
+}
+
+static bool CheckDimensionLength(const AccessingSet& array)
+{
+    if (array.GetElements().empty())
+        return false;
+    size_t dimCount = array.GetElements()[0].size();
+    SgArrayRefExp* arrayRef = array.GetElements()[0][0].array;
+    if (!arrayRef || !arrayRef->symbol())
+        return false;
+
+    vector<uint64_t> declaredDims;
+    declaredDims.reserve(dimCount);
+
+    DIST::Array* distArr = getDistArrayBySymbol(arrayRef->symbol());
+    if (distArr && distArr->GetDimSize() == (int)dimCount)
+    {
+        const auto& sizes = distArr->GetSizes();
+        bool valid = true;
+        for (size_t i = 0; i < dimCount && valid; ++i)
+        {
+            int lo = sizes[i].first;
+            int hi = sizes[i].second;
+            if (lo > hi)
+                valid = false;
+            else
+                declaredDims.push_back((uint64_t)(hi - lo + 1));
+        }
+        if (valid && declaredDims.size() == dimCount)
+        {
+            vector<ArrayDimension> testArray(dimCount);
+            for (size_t i = 0; i < dimCount; i++)
+                testArray[i] = { 1, 1, declaredDims[i], nullptr };
+            return AccessingSet({ testArray }).Diff(array).GetElements().empty();
+        }
+    }
+
+    return false;
+}
+
 static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes& privates, set<SgStatement*>& insertedPrivates)
 {
    SgStatement* spfStat = new SgStatement(SPF_ANALYSIS_DIR);
@@ -159,8 +380,11 @@ static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes&
    spfStat->setFileName(loop->loop->fileName());
    SgExpression* toAdd = new SgExpression(EXPR_LIST, new SgExpression(ACC_PRIVATE_OP), NULL, NULL);
    set<SgSymbol*> arraysToInsert;
+    std::cout << "First bp\n";
    for (const auto& [_, accessingSet] : privates)
    {
+        if (!CheckDimensionLength(accessingSet))
+            continue;
        for (const auto& arrayElement : accessingSet.GetElements())
        {
            if (arrayElement.empty())
@@ -187,16 +411,16 @@ static void AddPrivateArraysToLoop(LoopGraph* loop, const ArrayAccessingIndexes&
        }
        toAdd->setLhs(new SgVarRefExp(elem));
    }
-    
-    if (arraysToInsert.size() == 0)
-        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);

-    loop->loop->insertStmtBefore(*spfStat, *loop->loop->controlParent());
-    insertedPrivates.insert(spfStat);
+    if (arraysToInsert.size() != 0)
+    {
+        loop->loop->insertStmtBefore(*spfStat, *loop->loop->controlParent());
+        insertedPrivates.insert(spfStat);
+    }
 }

-void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, set<SgStatement*> &insertedPrivates)
-{  
+void findPrivateArrays(map<string, vector<LoopGraph*>>& loopGraph, map<FuncInfo*, vector<SAPFOR::BasicBlock*>>& FullIR, set<SgStatement*>& insertedPrivates)
+{
    map<LoopGraph*, ArrayAccessingIndexes> result;
    for (const auto& [fileName, loops] : loopGraph)
    {
@@ -210,11 +434,19 @@ void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*
            while (search_func && (!isSgProgHedrStmt(search_func)))
                search_func = search_func->controlParent();

-            for (const auto& [funcInfo, blocks]: FullIR)
-            {   
+            for (const auto& [funcInfo, blocks] : FullIR)
+            {
                if (funcInfo->fileName == fileName && funcInfo->funcPointer->GetOriginal() == search_func)
                {
-                    Region* loopRegion = new Region(loop, blocks);
+                    Region* loopRegion;
+                    try
+                    {
+                        loopRegion = new Region(loop, blocks);
+                    }
+                    catch (...)
+                    {
+                        continue;
+                    }
                    if (loopRegion->getBasickBlocks().size() <= 1)
                    {
                        delete(loopRegion);
@@ -226,9 +458,24 @@ void FindPrivateArrays(map<string, vector<LoopGraph*>> &loopGraph, map<FuncInfo*
                    delete(loopRegion);
                }
            }
-
            if (result.find(loop) != result.end() && !result[loop].empty())
                AddPrivateArraysToLoop(loop, result[loop], insertedPrivates);
        }
    }
-}
+
+    for (SgStatement* st : statementsToRemove)
+    {
+        SgFile::switchToFile(st->fileName());
+        st->deleteStmt();
+    }
+
+    for (auto& [filename, statements] : expToChange)
+    {
+        SgFile::switchToFile(filename);
+        for (auto& [statement, statementCopy] : statements) 
+        {
+            statement->insertStmtBefore(*statementCopy, *statement->controlParent());
+            statement->deleteStmt();
+        }
+    }
+}
--- a/src/PrivateAnalyzer/private_arrays_search.h
+++ b/src/PrivateAnalyzer/private_arrays_search.h
@@ -9,5 +9,4 @@
 #include "graph_loops.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);
-std::pair<SAPFOR::BasicBlock*, std::unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const std::vector<SAPFOR::BasicBlock*> blocks);
+void findPrivateArrays(std::map<std::string, std::vector<LoopGraph*>>& loopGraph, std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, std::set<SgStatement*>& insertedPrivates);
--- a/src/PrivateAnalyzer/range_structures.cpp
+++ b/src/PrivateAnalyzer/range_structures.cpp
@@ -29,7 +29,7 @@ static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const A
    vector<uint64_t> partSolution = FindParticularSolution(dim1, dim2);
    if (partSolution.empty())
        return NULL;
-    
+
    int64_t x0 = partSolution[0], y0 = partSolution[1];
    /* x = x_0 + c * t */
    /* y = y_0 + d * t */
@@ -44,10 +44,10 @@ static ArrayDimension* DimensionIntersection(const ArrayDimension& dim1, const A
    uint64_t tMax = min(tXMax, tYMax);
    if (tMin > tMax)
        return NULL;
-    
+
    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 , dim1.array };
    return result;
 }

@@ -57,12 +57,12 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
    ArrayDimension* intersection = DimensionIntersection(dim1, dim2);
    if (!intersection)
        return { dim1 };
-    
+
    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});
-    
+    if (dim1.start < intersection->start)
+        result.push_back({ dim1.start, dim1.step, (intersection->start - dim1.start) / dim1.step, dim1.array });
+
    /* add the parts between intersection steps */
    if (intersection->step > dim1.step)
    {
@@ -70,7 +70,7 @@ static vector<ArrayDimension> DimensionDifference(const ArrayDimension& dim1, co
        uint64_t interValue = intersection->start;
        for (int64_t i = start; interValue <= intersection->start + intersection->step * (intersection->tripCount - 1); i++)
        {
-            result.push_back({interValue + dim1.step, dim1.step, intersection->step / dim1.step, dim1.array});
+            result.push_back({ interValue + dim1.step, dim1.step, intersection->step / dim1.step, dim1.array });
            interValue += intersection->step;
        }
    }
@@ -109,7 +109,7 @@ static vector<ArrayDimension> ElementsIntersection(const vector<ArrayDimension>&
 {
    if (firstElement.empty() || secondElement.empty())
        return {};
-    
+
    size_t dimAmount = firstElement.size();
    /* check if there is no intersecction */
    for (size_t i = 0; i < dimAmount; i++)
@@ -132,14 +132,16 @@ static vector<ArrayDimension> ElementsIntersection(const vector<ArrayDimension>&
 static vector<vector<ArrayDimension>> ElementsDifference(const vector<ArrayDimension>& firstElement,
    const vector<ArrayDimension>& secondElement)
 {
-    if (firstElement.empty() || secondElement.empty())
+    if (firstElement.empty())
        return {};
-    
+    if (secondElement.empty())
+        return { firstElement };
+
    vector<ArrayDimension> intersection = ElementsIntersection(firstElement, secondElement);
    vector<vector<ArrayDimension>> result;
    if (intersection.empty())
        return { firstElement };
-    
+
    for (int i = 0; i < firstElement.size(); i++)
    {
        auto dimDiff = DimensionDifference(firstElement[i], secondElement[i]);
@@ -188,7 +190,7 @@ bool AccessingSet::ContainsElement(const vector<ArrayDimension>& element) const
 {
    vector<vector<ArrayDimension>> tails;
    FindUncovered(element, tails);
-    return !tails.empty();
+    return tails.empty();
 }

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

    AccessingSet intersection = this->Intersect(secondSet);
-    AccessingSet uncovered = *this;
-    vector<vector<ArrayDimension>> result;
-    for (const auto& element : intersection.GetElements())
+    vector<vector<ArrayDimension>> uncovered;
+    for (const auto& element : allElements)
    {
        vector<vector<ArrayDimension>> current_uncovered;
-        uncovered.FindUncovered(element, current_uncovered);
-        uncovered = AccessingSet(current_uncovered);
+        intersection.FindUncovered(element, current_uncovered);
+        uncovered.insert(uncovered.end(),
+            std::move_iterator(current_uncovered.begin()),
+            std::move_iterator(current_uncovered.end())
+        );
    }
    return uncovered;
 }
@@ -289,4 +293,4 @@ bool operator!=(const ArrayAccessingIndexes& lhs, const ArrayAccessingIndexes& r
            return true;

    return false;
-}
+}
--- a/src/PrivateAnalyzer/region.cpp
+++ b/src/PrivateAnalyzer/region.cpp
@@ -1,14 +1,14 @@
-#include<vector>
-#include<map>
-#include<unordered_set>
-#include<unordered_map>
-#include<string>
+#include <algorithm>
+#include <vector>
+#include <map>
+#include <unordered_set>
+#include <unordered_map>
+#include <string>
 #include <numeric>
 #include <iostream>

 #include "range_structures.h"
 #include "region.h"
-
 #include "SgUtils.h"

 using namespace std;
@@ -23,7 +23,7 @@ static bool isParentStmt(SgStatement* stmt, SgStatement* parent)
 }

 /*returns head block and loop*/
-pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const vector<SAPFOR::BasicBlock*> blocks)
+static pair<SAPFOR::BasicBlock*, unordered_set<SAPFOR::BasicBlock*>> GetBasicBlocksForLoop(const LoopGraph* loop, const vector<SAPFOR::BasicBlock*> blocks)
 {
    unordered_set<SAPFOR::BasicBlock*> block_loop;
    SAPFOR::BasicBlock* head_block = nullptr;
@@ -62,14 +62,14 @@ static void BuildLoopIndex(map<string, LoopGraph*>& loopForIndex, LoopGraph* loo
 static string FindIndexName(int pos, SAPFOR::BasicBlock* block, map<string, LoopGraph*>& loopForIndex) {
    unordered_set<SAPFOR::Argument*> args = { block->getInstructions()[pos]->getInstruction()->getArg1() };

-    for (int i = pos - 1; i >= 0; i--) 
+    for (int i = pos - 1; i >= 0; i--)
    {
        SAPFOR::Argument* res = block->getInstructions()[i]->getInstruction()->getResult();
-        if (res && args.find(res) != args.end()) 
+        if (res && args.find(res) != args.end())
        {
            SAPFOR::Argument* arg1 = block->getInstructions()[i]->getInstruction()->getArg1();
            SAPFOR::Argument* arg2 = block->getInstructions()[i]->getInstruction()->getArg2();
-            if (arg1) 
+            if (arg1)
            {
                string name = arg1->getValue();
                int idx = name.find('%');
@@ -93,7 +93,7 @@ static string FindIndexName(int pos, SAPFOR::BasicBlock* block, map<string, Loop
    return "";
 }

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

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

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

            auto* ref = isSgArrayRefExp(instruction->getInstruction()->getExpression());
+            if (!ref)
+                continue;
            int fillCount = 0;

-            while (!index_vars.empty() && !refPos.empty())
+            vector<pair<int, int>> coeffsForDims;
+            int subs = ref->numberOfSubscripts();
+            for (int i = 0; ref && i < ref->numberOfSubscripts(); ++i)
+            {
+                const vector<int*>& coeffs = getAttributes<SgExpression*, int*>(ref->subscript(i), set<int>{ INT_VAL });
+                if (coeffs.size() == 1)
+                {
+                    const pair<int, int> coef(coeffs[0][0], coeffs[0][1]);
+                    coeffsForDims.push_back(coef);
+                }
+
+            }
+            coeffsForDims = { coeffsForDims.rbegin(), coeffsForDims.rend() };
+
+            while (!index_vars.empty() && !refPos.empty() && !coeffsForDims.empty())
            {
                auto var = index_vars.back();
                int currentVarPos = refPos.back();
                ArrayDimension current_dim;
                if (var->getType() == SAPFOR::CFG_ARG_TYPE::CONST)
-                    current_dim = { stoul(var->getValue()), 1, 1, ref};
+                    current_dim = { stoul(var->getValue()), 1, 1, ref };
                else
                {
                    string name, full_name = var->getValue();
                    int pos = full_name.find('%');
                    LoopGraph* currentLoop;
-                    if (pos != -1) 
+                    if (pos != -1)
                    {
                        name = full_name.substr(pos + 1);
                        if (loopForIndex.find(name) != loopForIndex.end())
-                            currentLoop = loopForIndex[name];                        
+                            currentLoop = loopForIndex[name];
                        else
                            return -1;
                    }
-                    else 
+                    else
                    {
                        name = FindIndexName(currentVarPos, block, loopForIndex);
                        if (name == "")
                            return -1;

                        if (loopForIndex.find(name) != loopForIndex.end())
-                            currentLoop = loopForIndex[name];                        
+                            currentLoop = loopForIndex[name];
                        else
                            return -1;
                    }

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

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

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

 }

+static void RemoveHeaderConnection(SAPFOR::BasicBlock* header, const unordered_set<SAPFOR::BasicBlock*>& blockSet, unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
+{
+    for (SAPFOR::BasicBlock* block : blockSet)
+    {
+        bool isCycleBlock = false;
+        for (SAPFOR::BasicBlock* prevBlock : block->getPrev())
+            isCycleBlock = isCycleBlock || (blockSet.find(prevBlock) != blockSet.end());
+
+        if (isCycleBlock)
+        {
+            bbToRegion[block]->removeNextRegion(bbToRegion[header]);
+            bbToRegion[header]->removePrevRegion(bbToRegion[block]);
+        }
+    }
+}
+
+static void DFS(Region* block, vector<Region*>& result, unordered_set<Region*> cycleBlocks)
+{
+    for (Region* nextBlock : block->getNextRegions())
+    {
+        if (cycleBlocks.find(nextBlock) != cycleBlocks.end())
+            DFS(nextBlock, result, cycleBlocks);
+    }
+    result.push_back(block);
+}
+
+bool HasCycle(Region* block, const std::unordered_set<Region*>& cycleBlocks, std::unordered_set<Region*>& visitedBlocks)
+{
+    if (visitedBlocks.find(block) != visitedBlocks.end())
+        return true;
+    visitedBlocks.insert(block);
+    for (Region* nextBlock : block->getNextRegions())
+    {
+        if (cycleBlocks.find(nextBlock) != cycleBlocks.end() && HasCycle(nextBlock, cycleBlocks, visitedBlocks))
+            return true;
+    }
+    return false;
+}
+
+bool TopologySort(std::vector<Region*>& basikBlocks, Region* header)
+{
+    unordered_set<Region*> cycleBlocks(basikBlocks.begin(), basikBlocks.end());
+    unordered_set<Region*> visitedBlocks;
+    if (HasCycle(header, cycleBlocks, visitedBlocks))
+        return false;
+    vector<Region*> result;
+    DFS(header, result, cycleBlocks);
+    reverse(result.begin(), result.end());
+    basikBlocks = move(result);
+    return true;
+}
+
 static void SetConnections(unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion, const unordered_set<SAPFOR::BasicBlock*>& blockSet)
 {
    for (SAPFOR::BasicBlock* block : blockSet)
@@ -215,25 +302,26 @@ static void SetConnections(unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegi
        for (SAPFOR::BasicBlock* nextBlock : block->getNext())
            if (bbToRegion.find(nextBlock) != bbToRegion.end())
                bbToRegion[block]->addNextRegion(bbToRegion[nextBlock]);
-         
+
        for (SAPFOR::BasicBlock* prevBlock : block->getPrev())
            if (bbToRegion.find(prevBlock) != bbToRegion.end())
                bbToRegion[block]->addPrevRegion(bbToRegion[prevBlock]);
    }
 }

-static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks, const unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
+static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*>& Blocks, unordered_map<SAPFOR::BasicBlock*, Region*>& bbToRegion)
 {
    Region* region = new Region;
    auto [header, blockSet] = GetBasicBlocksForLoop(loop, Blocks);
+    RemoveHeaderConnection(header, blockSet, bbToRegion);
    if (bbToRegion.find(header) != bbToRegion.end())
-        region->setHeader(bbToRegion.at(header));    
+        region->setHeader(bbToRegion.at(header));
    else
    {
        printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
        return NULL;
    }
-    
+
    for (SAPFOR::BasicBlock* block : blockSet)
        if (bbToRegion.find(block) != bbToRegion.end())
            region->addBasickBlocks(bbToRegion.at(block));
@@ -244,6 +332,8 @@ static Region* CreateSubRegion(LoopGraph* loop, const vector<SAPFOR::BasicBlock*
            continue;
        region->addSubRegions(CreateSubRegion(childLoop, Blocks, bbToRegion));
    }
+    if (!TopologySort(region->getBasickBlocks(), region->getHeader()))
+        throw std::runtime_error("Unnoticed cycle");
    return region;
 }

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

    }
    this->header = bbToRegion[header];
    SetConnections(bbToRegion, blockSet);
+    RemoveHeaderConnection(header, blockSet, bbToRegion);
    //create subRegions
    for (LoopGraph* childLoop : loop->children)
    {
        if (!childLoop->isFor())
            continue;
        subRegions.insert(CreateSubRegion(childLoop, Blocks, bbToRegion));
-    }
-}
+        }
+    if (!TopologySort(basickBlocks, this->header))
+        throw std::runtime_error("Unnoticed cycle");
+}
--- a/src/PrivateAnalyzer/region.h
+++ b/src/PrivateAnalyzer/region.h
@@ -8,6 +8,11 @@
 #include "graph_loops.h"
 #include "CFGraph/CFGraph.h"

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

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

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

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

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

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

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

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

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

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

 private:
-    std::unordered_set<Region*> subRegions, basickBlocks;
+    std::vector<Region*> basickBlocks;
+    std::unordered_set<Region*> subRegions;
    /*next Region which is BB for current BB Region*/
    std::unordered_set<Region*> nextRegions;
    /*prev Regions which is BBs for current BB Region*/
    std::unordered_set<Region*> prevRegions;
    Region* header;
 };
+
+bool HasCycle(Region* block, const std::unordered_set<Region*>& cycleBlocks, std::unordered_set<Region*>& visitedBlocks);
+
+bool TopologySort(std::vector<Region*>& basikBlocks, Region* header);
--- a/src/Sapfor.cpp
+++ b/src/Sapfor.cpp
@@ -23,6 +23,7 @@
 #include "ParallelizationRegions/ParRegions_func.h"
 #include "ParallelizationRegions/resolve_par_reg_conflicts.h"
 #include "ParallelizationRegions/expand_extract_reg.h"
+#include "ParallelizationRegions/merge_regions.h"

 #include "Distribution/Distribution.h"
 #include "Distribution/GraphCSR.h"
@@ -741,7 +742,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
        else if (curr_regime == LOOP_DATA_DEPENDENCIES)
            doDependenceAnalysisOnTheFullFile(file, 1, 1, 1);
        else if (curr_regime == REMOVE_DVM_DIRS || curr_regime == REMOVE_DVM_DIRS_TO_COMMENTS || curr_regime == REMOVE_SPF_DIRS) {
-            bool removeDvm = (curr_regime == REMOVE_DVM_DIRS || curr_regime == REMOVE_DVM_DIRS);
+            bool removeDvm = (curr_regime == REMOVE_DVM_DIRS);
            bool removeSpf = (curr_regime == REMOVE_SPF_DIRS);
            bool toComment = (curr_regime == REMOVE_DVM_DIRS_TO_COMMENTS);
            removeDvmSpfDirectives(file, removeDvm, removeSpf, toComment);
@@ -943,7 +944,7 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
            }
        }
        else if (curr_regime == MOVE_OPERATORS)        
-            moveOperators(file, loopGraph, fullIR, countOfTransform);        
+            moveOperators(file, fullIR, countOfTransform);
        else if (curr_regime == PRIVATE_REMOVING_ANALYSIS)
        {
            auto itFound = loopGraph.find(file->filename());
@@ -1264,6 +1265,8 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne

        moveAllocatesInterproc(arrayLinksByFuncCalls);

+        propagateRegionInfo(declaredArrays, arrayLinksByFuncCalls, subs_parallelRegions);
+
        removeDistrStateFromDeadFunctions(allFuncInfo, declaredArrays);
        propagateArrayFlags(arrayLinksByFuncCalls, declaredArrays, SPF_messages);
    }
@@ -1681,30 +1684,11 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
        findDeadFunctionsAndFillCalls(allFuncInfo_IR, SPF_messages, true);
    else if (curr_regime == GET_ALL_ARRAY_DECL)
    {
-        bool hasNonDefaultReg = false;
-        for (auto &elem : subs_parallelRegions)
-            if (elem->GetName() != "DEFAULT")
-                hasNonDefaultReg = true;
-
-        if (hasNonDefaultReg)
+        if (ignoreArrayDistributeState) 
        {
-            for (auto array : declaredArrays)
-            {
-                if (array.second.first->GetRegionsName().size() == 0)
-                    array.second.first->SetDistributeFlag(DIST::NO_DISTR);
-                else if (array.second.first->GetRegionsName().size() == 1)
-                {
-                    string regName = *array.second.first->GetRegionsName().begin();
-                    convertToLower(regName);
-                    if (regName == "default")
-                        array.second.first->SetDistributeFlag(DIST::NO_DISTR);
-                }
-            }
-        }
-
-        if (ignoreArrayDistributeState)
            for (auto array : declaredArrays)
                array.second.first->SetDistributeFlag(DIST::NO_DISTR);
+        }
    }
    else if (curr_regime == GCOV_PARSER)
    {
@@ -1921,10 +1905,11 @@ static bool runAnalysis(SgProject &project, const int curr_regime, const bool ne
    else if (curr_regime == TRANSFORM_ASSUMED_SIZE_PARAMETERS)
        transformAssumedSizeParameters(allFuncInfo);
    else if (curr_regime == FIND_PRIVATE_ARRAYS_ANALYSIS)
-        FindPrivateArrays(loopGraph, fullIR, insertedPrivates);
-
+        findPrivateArrays(loopGraph, fullIR, insertedPrivates);
+    else if (curr_regime == MERGE_REGIONS)
+        mergeRegions(parallelRegions, allFuncInfo);
    else if (curr_regime == ARRAY_PROPAGATION)
-        ArrayConstantPropagation(project);
+        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.;
@@ -2379,6 +2364,7 @@ void runPass(const int curr_regime, const char *proj_name, const char *folderNam
    case FIX_COMMON_BLOCKS:
    case TEST_PASS:
    case SET_IMPLICIT_NONE:
+    case MERGE_REGIONS:
        runAnalysis(*project, curr_regime, false);
    case SUBST_EXPR_RD_AND_UNPARSE:
    case SUBST_EXPR_AND_UNPARSE:
--- a/src/Sapfor.h
+++ b/src/Sapfor.h
@@ -88,6 +88,8 @@ enum passes {
    REMOVE_DVM_INTERVALS,
    VERIFY_DVM_DIRS,

+    MERGE_REGIONS,
+
    REMOVE_DIST_ARRAYS_FROM_IO,

    SUBST_EXPR,
@@ -273,6 +275,7 @@ static void setPassValues()
    passNames[VERIFY_DVM_DIRS] = "VERIFY_DVM_DIRS";
    passNames[REMOVE_DVM_DIRS_TO_COMMENTS] = "REMOVE_DVM_DIRS_TO_COMMENTS";
    passNames[REMOVE_SPF_DIRS] = "REMOVE_SPF_DIRS";
+    passNames[MERGE_REGIONS] = "MERGE_REGIONS";
    passNames[REMOVE_DIST_ARRAYS_FROM_IO] = "REMOVE_DIST_ARRAYS_FROM_IO";
    passNames[SUBST_EXPR] = "SUBST_EXPR";
    passNames[SUBST_EXPR_RD] = "SUBST_EXPR_RD";
--- a/src/Transformations/FunctionInlining/inliner.cpp
+++ b/src/Transformations/FunctionInlining/inliner.cpp
@@ -1089,6 +1089,8 @@ static int clean(const string& funcName, SgStatement* funcSt, const map<string,
            }

            SgGotoStmt* gotoSt = new SgGotoStmt(*contLab);
+            if (st->label())
+                gotoSt->setLabel(*st->label());
            st->insertStmtBefore(*gotoSt, *st->controlParent());

            toDelete.push_back(st);
--- a/src/Transformations/FunctionPurifying/function_purifying.cpp
+++ b/src/Transformations/FunctionPurifying/function_purifying.cpp
@@ -234,9 +234,8 @@ static bool hasDvmParallel(SgStatement *func)
    return false;
 }

-void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFuncInfo)
-{
-    map<string, vector<int>> assumedSizeArraysByFunc;
+static map<FuncInfo*, bool> createDvmParallelInfo(const map<string, vector<FuncInfo*>>& allFuncInfo) {
+    map<FuncInfo*, bool> hasDvmParallelMap;

    for (auto& funcByFile : allFuncInfo)
    {
@@ -249,7 +248,63 @@ void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFun
            if (prog == NULL)
                continue;

-            if (!hasDvmParallel(prog))
+            hasDvmParallelMap[func] = hasDvmParallel(prog);
+        }
+    }
+
+    bool changed = true;
+    while (changed) 
+    {
+        changed = false;
+
+        for (auto& funcByFile : allFuncInfo)
+        {
+            for (auto& func : funcByFile.second)
+            {
+                if (!hasDvmParallelMap[func]) 
+                {
+                    bool hasParallel = false;
+                    for (auto& callF : func->callsFromV)
+                    {
+                        if (hasDvmParallelMap[callF]) 
+                        {
+                            hasParallel = true;
+                            break;
+                        }
+                    }
+
+                    if (hasParallel)
+                    {
+                        changed = true;
+                        hasDvmParallelMap[func] = true;
+                    }
+
+                }
+            }
+        }
+    }
+
+    return hasDvmParallelMap;
+}
+
+
+void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFuncInfo)
+{
+    map<string, vector<int>> assumedSizeArraysByFunc;
+    const map<FuncInfo*, bool> hasDvmParallelMap = createDvmParallelInfo(allFuncInfo);
+    
+    for (auto& funcByFile : allFuncInfo)
+    {
+        if (SgFile::switchToFile(funcByFile.first) == -1)
+            printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+
+        for (auto& func : funcByFile.second)
+        {
+            SgProgHedrStmt* prog = isSgProgHedrStmt(func->funcPointer->GetOriginal());
+            if (prog == NULL)
+                continue;
+
+            if (!hasDvmParallelMap.at(func))
                continue;

            vector<SgSymbol*> parNames;
@@ -259,7 +314,8 @@ void transformAssumedSizeParameters(const map<string, vector<FuncInfo*>>& allFun
            bool hasRefs = false;
            for (int z = 0; z < func->funcParams.countOfPars; ++z)
            {
-                if (func->funcParams.parametersT[z] == ARRAY_T)
+                if (func->funcParams.parametersT[z] == ARRAY_T ||
+                    func->funcParams.parametersT[z] == STRING_ARRAY_T)
                {
                    auto s = prog->parameter(z);
                    const string name = s->identifier();
--- a/src/Transformations/MoveOperators/move_operators.cpp
+++ b/src/Transformations/MoveOperators/move_operators.cpp
--- a/src/Transformations/MoveOperators/move_operators.h
+++ b/src/Transformations/MoveOperators/move_operators.h
@@ -3,4 +3,4 @@
 #include "../../GraphLoop/graph_loops.h"
 #include "../../CFGraph/CFGraph.h"

-void moveOperators(SgFile *file, std::map<std::string, std::vector<LoopGraph*>>& loopGraph, const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);
+void moveOperators(SgFile* file, const std::map<FuncInfo*, std::vector<SAPFOR::BasicBlock*>>& FullIR, int& countOfTransform);
--- a/src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp
+++ b/src/Transformations/ReplaceArraysInIO/replace_dist_arrays_in_io.cpp
@@ -504,7 +504,7 @@ static void replaceArrayInFragment(SgSymbol* replace_symb,
    }
 }

-static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
+static bool ioRegionBorder(SgStatement* stat, SgStatement* last_io_bound)
 {
    auto var = stat->variant();

@@ -535,14 +535,24 @@ static bool ioReginBorder(SgStatement* stat, SgStatement* last_io_bound)
    if (last_io_bound && last_io_bound->lastNodeOfStmt() && last_io_bound->lastNodeOfStmt() == stat)
        return true;

-    int parent_var;
-
    if (var == CONTROL_END && border_stats.find(stat->controlParent()->variant()) != border_stats.end())
        return true;

    return false;
 }

+FuncInfo* getCurrentFuncInfo(const vector<FuncInfo*>& fileFuncInfo, int line)
+{
+    for (auto* func : fileFuncInfo)
+    {
+        if (func->linesNum.first <= line && line <= func->linesNum.second)
+            return func;
+    }
+
+    printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
+    return NULL;
+}
+
 void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                                  const map<string, vector<FuncInfo*>>& allFuncInfo,
                                  map<string, vector<Messages>>& SPF_messages,
@@ -562,6 +572,8 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
            if (SgFile::switchToFile(current_file_name) == -1)
                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);

+            FuncInfo *current_func_info = NULL;
+
            auto func_info_it = allFuncInfo.find(current_file_name);
            if (func_info_it == allFuncInfo.end())
                printInternalError(convertFileName(__FILE__).c_str(), __LINE__);
@@ -588,13 +600,12 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                {
                    curr_stmt = lines.stats.first->GetOriginal();
                    end = lines.stats.second->GetOriginal()->lexNext();
+                    current_func_info = getCurrentFuncInfo(func_info_it->second, curr_stmt->lineNumber());
                }

                map<SgSymbol*, set<SgStatement*>> need_replace;
                SgStatement* last_io_bound = NULL;

-                FuncInfo *current_func_info = NULL;
-
                while (curr_stmt != end)
                {
                    if (!curr_stmt)
@@ -604,18 +615,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,

                    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__);
+                        current_func_info = getCurrentFuncInfo(func_info_it->second, curr_stmt->lineNumber());

                        curr_stmt = curr_stmt->lexNext();
                        while (curr_stmt && !isSgExecutableStatement(curr_stmt))
@@ -628,7 +628,7 @@ void replaceDistributedArraysInIO(vector<ParallelRegion*>& regions,
                            break;
                    }

-                    if (ioReginBorder(curr_stmt, last_io_bound))
+                    if (ioRegionBorder(curr_stmt, last_io_bound))
                    {
                        for (const auto& by_array_to_copy : need_replace)
                        {
--- a/src/Utils/PassManager.h
+++ b/src/Utils/PassManager.h
@@ -318,10 +318,11 @@ 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({ ARRAY_PROPAGATION, CALL_GRAPH2, CALL_GRAPH, BUILD_IR, LOOP_GRAPH, LOOP_ANALYZER_DATA_DIST_S2 }) <= Pass(FIND_PRIVATE_ARRAYS_ANALYSIS);
    list({ FIND_PRIVATE_ARRAYS_ANALYSIS, CONVERT_LOOP_TO_ASSIGN, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(FIND_PRIVATE_ARRAYS);

    list({ BUILD_IR, CALL_GRAPH2, RESTORE_LOOP_FROM_ASSIGN, REVERT_SUBST_EXPR_RD }) <= Pass(MOVE_OPERATORS);
+    Pass(CREATE_TEMPLATE_LINKS) <= Pass(MERGE_REGIONS);

    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/SgUtils.cpp
+++ b/src/Utils/SgUtils.cpp
@@ -577,10 +577,20 @@ string removeIncludeStatsAndUnparse(SgFile *file, const char *fileName, const ch
                for (auto& incl : inclByPos.second)
                    inlcude += (renameIncludes ? renameInclude(incl) : incl);

-            if (st->comments())
-                st->setComments((inlcude + st->comments()).c_str());
+            //check inserted operators
+            SgStatement* toInsert = st;
+            do {
+                auto lexPrev = toInsert->lexPrev();
+                if (lexPrev && lexPrev->variant() > 0 && lexPrev->lineNumber() < 0)
+                    toInsert = lexPrev;
+                else
+                    break;                
+            } while (true);
+
+            if (toInsert->comments())
+                toInsert->setComments((inlcude + toInsert->comments()).c_str());
            else
-                st->addComment(inlcude.c_str());
+                toInsert->addComment(inlcude.c_str());
        }
    }

@@ -648,7 +658,7 @@ string removeIncludeStatsAndUnparse(SgFile *file, const char *fileName, const ch

                if (wasDeleted)
                {
-                    if (str.size() || str.back() != '\n')
+                    if (str.size() && str.back() != '\n')
                        str += '\n';
                    st->setComments(str.c_str());
                }
--- a/src/Utils/version.h
+++ b/src/Utils/version.h
@@ -1,3 +1,3 @@
 #pragma once

-#define VERSION_SPF "2465"
+#define VERSION_SPF "2480"
Author	SHA1	Message	Date
ALEXks	d5919e5739	refactored	2026-04-19 20:29:23 +03:00
ALEXks	d77b6d5288	refactored	2026-04-19 20:25:20 +03:00
xnpster	7d45f5babc	marge_regions: rename	2026-04-19 19:17:14 +03:00
xnpster	f43247b6da	resolve_par_reg_conflicts: generate unique names, region merging: generate common blocks with _c suffix	2026-04-19 18:32:50 +03:00
xnpster	bafd8a8f48	region merging: derive array types	2026-04-19 18:32:50 +03:00
xnpster	d0712d1241	draft of parallel regions merging pass	2026-04-19 18:32:49 +03:00
ALEXks	54e83e194d	added IPA to complete the formation of names of parallelization regions	2026-04-18 20:33:30 +03:00
ALEXks	b87b18615d	fixed DCLARE analysis	2026-04-14 16:44:06 +03:00
ALEXks	e733d3d68a	improved and fixed transformAssumedSizeParameters function	2026-04-14 11:47:59 +03:00
Alexander_KS	fb3ac921cc	Merge pull request 'replace_io_arrays' (#80 ) from replace_io_arrays into master	2026-04-12 20:16:41 +03:00
ALEXks	a8ddc94734	version updated	2026-04-12 20:16:23 +03:00
xnpster	db5062c416	REMOVE_DIST_ARRAYS_FROM_IO: find current FuncInfo properly	2026-04-12 15:32:09 +03:00
xnpster	b71df882fb	REMOVE_DIST_ARRAYS_FROM_IO: fix type, add TODO	2026-04-12 15:32:09 +03:00
ALEXks	2d25a61ee7	fixed analysis of arrays with type character in function parameters	2026-04-10 20:09:50 +03:00
Alexander_KS	3378ae5fbd	Merge pull request 'private_arrays2' (#79 ) from private_arrays2 into master	2026-04-10 17:29:40 +03:00
ALEXks	446f4d54d7	vesion updated	2026-04-10 17:29:20 +03:00
Oleg Nikitin	7bca67b75c	new changes	2026-04-10 17:24:59 +03:00
Oleg Nikitin	8632dfbf31	fixes	2026-04-10 17:24:59 +03:00
Oleg Nikitin	97e60e16be	add ddot, change array propagation	2026-04-10 17:24:59 +03:00
ALEXks	39abbafb3a	fixed intent insertion	2026-04-09 15:35:28 +03:00
Alexander_KS	a1e12f5c1c	Merge pull request 'egormayorov' (#78 ) from egormayorov into master	2026-03-27 08:29:34 +03:00
ALEXks	cad8c0913d	Merge branch 'master' into egormayorov	2026-03-27 08:28:44 +03:00
ALEXks	bde804cff6	updated	2026-03-27 08:27:25 +03:00
Egor Mayorov	589680a78b	fix files usage	2026-03-26 14:18:45 +03:00
ALEXks	88bac54901	fixed function prototype	2026-03-26 14:18:45 +03:00
ALEXks	0d4d2b78d8	updated	2026-03-26 14:18:45 +03:00
Egor Mayorov	bbac07202d	Add swith to file usage	2026-03-26 14:18:39 +03:00
ALEXks	9325723e69	updated projects	2026-03-20 15:32:24 +03:00
ALEXks	18ac53f342	fixed inliner	2026-03-19 13:04:26 +03:00
ALEXks	0bec2c6527	assign line number to intervals for loops	2026-03-10 20:33:02 +03:00
Alexander_KS	aa56778be1	Merge pull request 'Move operators pass fixes' (#77 ) from egormayorov into master	2026-03-10 10:03:36 +03:00
ALEXks	0a484e77de	version updated	2026-03-10 10:03:27 +03:00
Egor Mayorov	4818884d48	Remove redundant functions	2026-03-08 18:34:36 +03:00
Egor Mayorov	e172678e1b	fix freezing	2026-03-08 18:28:21 +03:00
Egor Mayorov	0a977146a7	Analyze program block by block & reorder operators only in basic blocks	2026-03-05 15:55:47 +03:00
Egor Mayorov	0b50e0630a	use rd	2026-03-05 15:55:47 +03:00
ALEXks	980ddeeac7	fixed build	2026-03-04 20:26:23 +03:00
Alexander_KS	788eeda22e	Merge pull request 'fix search algorithm' (#76 ) from private_arrays2 into master	2026-03-04 20:22:08 +03:00
ALEXks	4a9cba7b96	version updated	2026-03-04 20:22:01 +03:00
Oleg Nikitin	42044b60f1	fix algorythm	2026-03-04 09:40:54 +03:00
ALEXks	80a1fecb1c	fixed getStatementByFileAndLine	2026-03-03 09:18:15 +03:00
ALEXks	2db6bf4bdf	fixed recovering of includes	2026-03-03 09:00:42 +03:00