diff --git a/sapfor/experts/Sapfor_2017/_src/Transformations/checkpoints.cpp b/sapfor/experts/Sapfor_2017/_src/Transformations/checkpoints.cpp
index 44b7f11..96c382f 100644
--- a/sapfor/experts/Sapfor_2017/_src/Transformations/checkpoints.cpp
+++ b/sapfor/experts/Sapfor_2017/_src/Transformations/checkpoints.cpp
@@ -544,252 +544,6 @@ static SgStatement* createOpen(SgExpression* iostat, SgSymbol* files, SgExpressi
     return open;
 }
 
-static void processFunctionCallChain(SgStatement* func, const vector<FuncInfo*>& allFuncInfo, SgStatement* moduleF,
-                                     const vector<SgSymbol*>& loadS, SgExpression* iostat, SgArrayRefExp* journal, 
-                                     SgExpression& frmt, SgExpression& unit,
-                                     SgSymbol* files, SgExpression* fileIdx,
-                                     const int every, const vector<SgSymbol*>& everyS)
-{
-    //find function structure
-    FuncInfo* funcI = findFileInfoByName(func, allFuncInfo);
-
-    set<pair<FuncInfo*, FuncInfo*>> toProcess;
-    fillToProcess(funcI, toProcess);
-
-    map<FuncInfo*, SgStatement*> processedFrom;
-    for (auto& pairs : toProcess)
-    {
-        FuncInfo* funcTo = pairs.first;
-        FuncInfo* funcFrom = pairs.second;
-
-        int callNum = 1;
-        SgStatement* hedrTo = funcTo->funcPointer->GetOriginal();
-        SgStatement* hedrFrom = funcFrom->funcPointer->GetOriginal();
-        SgStatement* lastDecl = hedrFrom->lexNext();
-        while (lastDecl && !isSgExecutableStatement(lastDecl->lexNext()))
-            lastDecl = lastDecl->lexNext();
-
-        SgStatement* firstExec = lastDecl->lexNext();
-        vector<SgExpression*> local;
-        map<string, SgStatement*> localParams;
-        set<string> addedToList;
-        findLocalData(hedrFrom, firstExec, local, localParams, addedToList, allFuncInfo);
-
-        if (!processedFrom.count(funcFrom))
-        {
-            SgSymbol* modS = moduleF->symbol();
-            SgStatement* useSt = new SgStatement(USE_STMT);
-            useSt->setSymbol(*modS);
-            hedrFrom->insertStmtAfter(*useSt, *hedrFrom);
-
-            SgStatement* gotoBlock = new SgStatement(IF_NODE);
-            vector<SgStatement*> insertToGotoBlock;
-
-            gotoBlock->addComment("!GOTO LOAD BLOCK \n");
-            gotoBlock->setExpression(0, *new SgVarRefExp(loadS[0]) == *new SgValueExp(0));
-
-            if (funcFrom->isMain)
-            {
-                SgAssignStmt* loadOne = new SgAssignStmt(*new SgVarRefExp(loadS[0]), *new SgValueExp(1));
-                insertToGotoBlock.push_back(loadOne);
-                insertToGotoBlock.push_back(createOpenJ_old(iostat, journal, unit));
-
-                vector<SgStatement*> insertToifLoadOk;
-                SgIfStmt* ifLoadOk = new SgIfStmt(*iostat == *new SgValueExp(0));
-                insertToGotoBlock.push_back(ifLoadOk);
-
-                SgInputOutputStmt* read = new SgInputOutputStmt(READ_STAT, *makeExprList({ &frmt, &unit }, false), *fileIdx);
-                insertToifLoadOk.push_back(read);
-                insertToifLoadOk.push_back(new SgIOControlStmt(CLOSE_STAT, unit));
-                insertToifLoadOk.push_back(createOpen(iostat, files, fileIdx, unit));
-
-                read = new SgInputOutputStmt(READ_STAT, *makeExprList({ &frmt, &unit }, false), *new SgVarRefExp(loadS[3]));
-                SgIfStmt* ifLoadOk1 = new SgIfStmt(*iostat == *new SgValueExp(0), *read);
-                SgAssignStmt* loadZero = new SgAssignStmt(*new SgVarRefExp(loadS[0]), *new SgValueExp(0));
-                ifLoadOk1->insertStmtAfter(*loadZero, *ifLoadOk1);
-
-                insertToifLoadOk.push_back(ifLoadOk1);
-
-                firstExec->insertStmtBefore(*gotoBlock, *hedrFrom);
-
-                for (int z = insertToGotoBlock.size() - 1; z >= 0; --z)
-                    gotoBlock->insertStmtAfter(*insertToGotoBlock[z], *gotoBlock);
-
-                for (int z = insertToifLoadOk.size() - 1; z >= 0; --z)
-                    ifLoadOk->insertStmtAfter(*insertToifLoadOk[z], *ifLoadOk);
-
-                processedFrom[funcFrom] = ifLoadOk1->lexNext();
-            }
-            else
-            {
-                SgStatement* read = new SgInputOutputStmt(READ_STAT, *makeExprList({ &frmt, &unit }, false), *new SgVarRefExp(loadS[3]));
-                gotoBlock->insertStmtAfter(*read, *gotoBlock);
-                processedFrom[funcFrom] = gotoBlock->lexNext();
-                firstExec->insertStmtBefore(*gotoBlock, *hedrFrom);
-            }
-        }
-
-        for (auto& callInfo : funcFrom->callsFromDetailed)
-        {
-            auto& call = callInfo.pointerDetailCallsFrom;
-            SgStatement* st = NULL;
-
-            if (isSgFuncHedrStmt(hedrTo) && call.second == FUNC_CALL)
-            {
-                SgFunctionCallExp* callExp = (SgFunctionCallExp*)call.first;
-                if (!strcmp(callExp->funName()->identifier(), funcTo->funcName.c_str()))
-                {
-                    st = SgStatement::getStatmentByExpression(callExp);
-                    SgSymbol* buf = new SgSymbol(VARIABLE_NAME, ("SPF_CALL_" + funcTo->funcName + "_" + to_string(callNum)).c_str(), callExp->type(), funcFrom->funcPointer->GetOriginal());
-                    SgExpression* bufRef = new SgVarRefExp(buf);
-                    SgStatement* bufAssign = new SgAssignStmt(*bufRef, *callExp);
-                    st->insertStmtBefore(*bufAssign, *(st->controlParent()));
-                    replaceExprByExprInSt(st, callExp, bufRef);
-                    makeDeclaration(hedrFrom, { buf });
-
-                    for (int i = 0; i < callExp->numberOfArgs(); i++)
-                    {
-                        if (funcTo->funcParams.isArgInOut(i) || funcTo->funcParams.isArgOut(i))
-                        {
-                            SgSymbol* s, * sl;
-                            SgStatement* lst = hedrTo->lastNodeOfStmt();
-                            sl = lst->lexNext() ? lst->lexNext()->symbol() : NULL;
-                            for (s = hedrTo->symbol(); s != sl && s; s = s->next())
-                            {
-                                if (s->scope() == hedrTo && !strcmp(s->identifier(), funcTo->funcParams.identificators[i].c_str()))
-                                {
-                                    break;
-                                }
-                            }
-
-                            SgSymbol* argBuf = new SgSymbol(VARIABLE_NAME, ("SPF_ARG_" + funcTo->funcName + "_" + to_string(callNum) + "_" + to_string(i)).c_str(), s->type(), funcFrom->funcPointer->GetOriginal());
-                            SgExpression* argBufRef = new SgVarRefExp(argBuf);
-                            SgStatement* argBufAssign = new SgAssignStmt(*argBufRef, *(callExp->arg(i)));
-                            bufAssign->insertStmtBefore(*argBufAssign, *(st->controlParent()));
-                            SgStatement* decl = makeDeclaration(hedrFrom, { argBuf });
-
-                            for (int i = 0; i < 3; i++)
-                            {
-                                SgExpression* e;
-                                if (e = decl->expr(i))
-                                    decl->setExpression(i, CalculateInteger(ReplaceConstant(e)));
-                            }
-
-                        }
-                    }
-                    st = bufAssign;
-                    callNum++;
-                }
-            }
-            else if (isSgProcHedrStmt(hedrTo) && call.second == PROC_STAT)
-            {
-                //TODO: need to revise!!
-                /*SgCallStmt* callSt = (SgCallStmt*)call.first;
-                if (!strcmp(callSt->name()->identifier(), funcTo->funcName.c_str())) {
-                    st = callSt;
-                    for (int i = 0; i < callSt->numberOfArgs(); i++)
-                    {
-                        if (funcTo->funcParams.isArgInOut(i) || funcTo->funcParams.isArgOut(i))
-                        {
-                            SgSymbol* buf1 = new SgSymbol(VARIABLE_NAME, "TEMP1", callSt->arg(i)->type(), hedrFrom);
-                            SgExpression* buf1Ref = new SgVarRefExp(buf1);
-                            SgStatement* buf1Assign = new SgAssignStmt(*buf1Ref, *(callSt->arg(i)));
-                            st->insertStmtBefore(*buf1Assign, *(st->controlParent()));
-                        }
-                    }
-                }*/
-            }
-
-            if (st)
-            {
-                SgStatement* loadBlock = new SgStatement(IF_NODE);
-                SgStatement* loadBlockLast = NULL;
-                SgStatement* storeBlock = new SgStatement(IF_NODE);
-
-                st->insertStmtBefore(*loadBlock, *st->controlParent());
-                st->insertStmtAfter(*storeBlock, *st->controlParent());
-
-                loadBlock->addComment("! LOAD CHECKPOINT\n");
-                const int labNum = getNextFreeLabel();
-                auto loadblockLab = new SgLabel(labNum);
-                loadBlock->setLabel(*loadblockLab);
-
-                SgIfStmt* gotoIf = new SgIfStmt(*new SgVarRefExp(loadS[3]) == *new SgValueExp(labNum), *new SgGotoStmt(*loadblockLab));
-                processedFrom[funcFrom]->insertStmtAfter(*gotoIf, *(processedFrom[funcFrom]->controlParent()));
-
-                storeBlock->addComment("! STORE CHECKPOINT\n");
-
-                //TODO: this block incorrect!!
-                storeBlock->setExpression(0, *new SgVarRefExp(everyS[0]) >= *new SgValueExp(every));
-
-                vector<SgStatement*> insertToLoadS;
-
-                loadBlock->setExpression(0, *new SgVarRefExp(loadS[0]) == *new SgValueExp(0));
-                loadBlock->addComment("! LOAD DATA FROM CHECKPOINT\n");
-
-                //READ DATA
-                if (local.size())
-                {
-                    auto dataRead = new SgInputOutputStmt(READ_STAT, unit, *makeExprList(local));
-                    loadBlock->insertStmtAfter(*dataRead, *loadBlock);
-                }
-            }
-        }
-    }
-}
-
-static void processModules(SgFile* file, const vector<FuncInfo*>& allFuncInfo)
-{
-    vector<SgStatement*> modules;
-    findModulesInFile(file, modules);
-    for (auto& mod : modules)
-    {
-        /*if (!strcmp(mod->symbol()->identifier(), "spf_module_checkpoint")) {
-            std::cout << "was here" << std::endl;
-            continue;
-        }*/
-
-        char pref[5];
-        strncpy(pref, mod->symbol()->identifier(), 4);
-        pref[4] = '\0';
-        if (!strcmp(pref, "spf_"))
-            continue;
-
-        bool hasContains = false;
-        SgStatement* st = mod->lexNext();
-        while (st != mod->lastNodeOfStmt() && !hasContains)
-        {
-            hasContains = st->variant() == CONTAINS_STMT;
-            st = st->lexNext();
-        }
-
-        vector<SgExpression*> local;
-        map<string, SgStatement*> localParams;
-        set<string> addedToList;
-        findLocalData(mod, hasContains ? st : mod->lastNodeOfStmt(), local, localParams, addedToList, allFuncInfo);
-
-        SgProcHedrStmt* newF = new SgProcHedrStmt((string("spf_cp_") + mod->symbol()->identifier()).c_str());
-        if (!hasContains)
-            mod->lastNodeOfStmt()->insertStmtBefore(*new SgStatement(CONTAINS_STMT), *mod);
-        mod->lastNodeOfStmt()->insertStmtBefore(*newF, *mod);
-
-        newF->AddArg("unit_f", *SgTypeInt());
-        newF->AddArg("type_of_op", *SgTypeInt());
-
-        if (local.size())
-        {
-            SgExpression& unit = SgAssignOp(*new SgKeywordValExp("unit"), *new SgVarRefExp(*newF->parameter(0)));
-            auto dataRead = new SgInputOutputStmt(READ_STAT, unit, *makeExprList(local));
-            auto dataWrite = new SgInputOutputStmt(WRITE_STAT, unit, *makeExprList(local));
-
-            SgIfStmt* ifBlock = new SgIfStmt(*new SgVarRefExp(*newF->parameter(1)) == *new SgValueExp(0), *dataRead, *dataWrite);
-            newF->lastNodeOfStmt()->insertStmtBefore(*ifBlock, *newF);
-
-            ifBlock->addComment(("!STORE OR LOAD " + to_string(local.size()) + " ITEMS\n").c_str());
-        }
-    }
-}
-
 static char* mergedChar(const char* l, const char* r)
 {
     int lenL = strlen(l);
@@ -825,7 +579,6 @@ static void renameEx(SgExpression* sizeEx, const char* funcName) {
         renameEx(sizeEx->rhs(), funcName);
 }
 
-
 static void findSizeEx(SgExpression* sizeEx, const map<string, SgStatement*>& moduleStmts, const map<string, SgStatement*>& moduleParamStmts, SgStatement* proc_moduleF, set<string>& addedModuleParams) {
     if (sizeEx->variant() == CONST_REF) {
         if (moduleParamStmts.count(sizeEx->symbol()->identifier()) == 1 && addedModuleParams.count(sizeEx->symbol()->identifier()) == 0) {
@@ -869,21 +622,30 @@ static void processCommonStmt(SgStatement* st, set<string>& commonVariables)
     }
 }
 
-static void processVarStmt(SgStatement* st, map<string, SgStatement*>& moduleStmts, const char* funcName)
+static void processVarStmt(SgStatement* st, map<string, SgStatement*>& moduleStmts, const char* funcName, 
+                           const set<string>& inFuncParam)
 {
-    int lenFuncName = strlen(funcName);
-
+    SgExpression* lhs2;
+    SgExpression* ex2 = st->expr(2);
+    
     SgExpression* ex = st->expr(0);
     SgExpression* lhs;
 
     SgStatement* baseStmt = st->copyPtr();
     baseStmt->expr(0)->setLhs(NULL);
     baseStmt->expr(0)->setRhs(NULL);
+    baseStmt->setExpression(2, NULL);
 
     while (ex && ex->lhs())
     {
         lhs = ex->lhs();
 
+        if (inFuncParam.count(lhs->symbol()->identifier()))
+        {
+            ex = ex->rhs();
+            continue;
+        }
+
         char* result = mergedChar(funcName, lhs->symbol()->identifier());
 
         SgSymbol* symb = new SgSymbol(lhs->symbol()->variant(), result, lhs->symbol()->type(), lhs->symbol()->scope());
@@ -961,9 +723,9 @@ static void processExternStmt(SgStatement* st, set<string>& externVars)
     }
 }
 
-static void processVarBlock(SgStatement* func, SgStatement* firstExec, map<string, SgStatement*>& moduleStmts, 
-                            map<string, SgStatement*>& moduleParamStmts, set<string>& commonVariables, 
-                            set<string>& externVars)
+static void processVarBlock(SgStatement* func, SgStatement* firstExec, map<string, SgStatement*>& moduleStmts,
+    map<string, SgStatement*>& moduleParamStmts, set<string>& commonVariables,
+    set<string>& externVars, FuncInfo* funcFrom, const set<string>& inFuncParam = {})
 {
     const char* funcName = func->symbol()->identifier();
 
@@ -972,7 +734,7 @@ static void processVarBlock(SgStatement* func, SgStatement* firstExec, map<strin
         if (st->variant() == COMM_STAT)
             processCommonStmt(st, commonVariables);
         else if (st->variant() == VAR_DECL || st->variant() == VAR_DECL_90)
-            processVarStmt(st, moduleStmts, funcName);
+            processVarStmt(st, moduleStmts, funcName, inFuncParam);
         else if (st->variant() == PARAM_DECL)
             processParamStmt(st, moduleParamStmts, funcName);
         else if (st->variant() == EXTERN_STAT)
@@ -980,9 +742,9 @@ static void processVarBlock(SgStatement* func, SgStatement* firstExec, map<strin
     }
 }
 
-static void insertStmtToModule(const map<string, SgStatement*>& moduleStmts, const map<string, SgStatement*>& moduleParamStmts, 
-                               set<string>& addedModuleParams, const set<string>& commonVariables, SgStatement* proc_moduleF, 
-                               set<string>& localVarNoParams, const set<string>& externVars)
+static void insertStmtToModule(const map<string, SgStatement*>& moduleStmts, const map<string, SgStatement*>& moduleParamStmts,
+    set<string>& addedModuleParams, const set<string>& commonVariables, SgStatement* proc_moduleF,
+    set<string>& localVarNoParams, const set<string>& externVars)
 {
     SgStatement* endProcModuleF = proc_moduleF->lastNodeOfStmt();
 
@@ -1016,6 +778,720 @@ static void insertStmtToModule(const map<string, SgStatement*>& moduleStmts, con
     }
 }
 
+static SgStatement* createLoadBlock(const vector<SgSymbol*>& loadS, FuncInfo*& funcI, SgExpression* iostat, SgArrayRefExp* journal, 
+                                    SgExpression& frmt, SgExpression& unit, SgSymbol* files, SgExpression* fileIdx, const int numOfFiles,
+                                    const vector<SgSymbol*>& profS, SgExpression& frmtProf, SgExpression& unitNull,
+                                    SgStatement* profCallS, SgStatement* profCallE, const set<string>& localVarNoParams,
+                                    const map<string, SgStatement*>& moduleStmts, const set<string>& commonVariables, bool createdModuleForIO,
+                                    const vector<string>& moduleNames, const int unitNum, 
+                                    const string& baseFunc, vector<vector<string>>& chainLocalVarNoParams,
+                                    bool isBaseFunc = true, SgSymbol* procLabelSymb = NULL)
+{
+    const char* funcName = funcI->funcName.c_str();
+    vector<SgStatement*> insertToLoadS;
+
+    SgStatement* loadBlock = new SgStatement(IF_NODE);
+    loadBlock->addComment("! LOAD CHECKPOINT\n");
+
+    loadBlock->setExpression(0, *new SgVarRefExp(loadS[4]) == *new SgValueExp(1)); //*new SgVarRefExp(loadS[0])
+
+    if (funcI->isMain)
+    {
+        SgAssignStmt* init = new SgAssignStmt(*new SgVarRefExp(loadS[4]), *new SgValueExp(0));
+        insertToLoadS.push_back(init);
+        insertToLoadS.push_back(createOpenJ_old(iostat, journal, unit));
+    }
+
+    vector<SgStatement*> insertToifLoadOk;
+    SgIfStmt* ifLoadOk = new SgIfStmt(*iostat == *new SgValueExp(0));
+    insertToLoadS.push_back(ifLoadOk);
+
+    if (funcI->isMain)
+    {
+        SgInputOutputStmt* read = new SgInputOutputStmt(READ_STAT, *makeExprList({ &frmt, &unit }, false), *fileIdx); //*makeExprList({ fileIdx, labelIdx })
+        insertToifLoadOk.push_back(read);
+        insertToifLoadOk.push_back(new SgIOControlStmt(CLOSE_STAT, unit));
+        insertToifLoadOk.push_back(createOpen(iostat, files, fileIdx, unit));
+    }
+
+    SgIfStmt* ifLoadOk1 = new SgIfStmt(*iostat == *new SgValueExp(0)); //, *new SgIOControlStmt(CLOSE_STAT, unit)
+
+    insertToifLoadOk.push_back(ifLoadOk1);
+
+    if (funcI->isMain)
+    {
+        SgAssignStmt* init = new SgAssignStmt(*new SgVarRefExp(loadS[4]), *new SgValueExp(1));
+        ifLoadOk1->insertStmtAfter(*init, *ifLoadOk1);
+    }
+
+    if (isBaseFunc)
+    {
+        ifLoadOk1->insertStmtAfter(*new SgIOControlStmt(CLOSE_STAT, unit), *ifLoadOk1);
+        ifLoadOk1->insertStmtAfter(*new SgIfStmt(*fileIdx == *new SgValueExp(numOfFiles + 1), *new SgAssignStmt(*fileIdx, *new SgValueExp(1))), *ifLoadOk1);
+        ifLoadOk1->insertStmtAfter(*new SgAssignStmt(*fileIdx, *fileIdx + *new SgValueExp(1)), *ifLoadOk1);
+    }
+
+    ifLoadOk1->addComment("! LOAD DATA FROM CHECKPOINT\n"); 
+
+    vector<SgExpression*> commentArgs;
+    commentArgs.push_back(new SgValueExp(" SECONDS"));
+    commentArgs.push_back(&(*new SgVarRefExp(profS[1]) - *new SgVarRefExp(profS[0])));
+    commentArgs.push_back(new SgArrayRefExp(*files, *fileIdx));
+    commentArgs.push_back(new SgValueExp("SPF CHECKPOINT LOADED FROM "));
+
+    ifLoadOk1->insertStmtAfter(*new SgInputOutputStmt(WRITE_STAT, *makeExprList({ &frmtProf, &unitNull }, false), *makeExprList(commentArgs, false)), *ifLoadOk1);
+    ifLoadOk1->insertStmtAfter(*profCallE->copyPtr(), *ifLoadOk1);
+
+    // insert copy_block
+    for (auto localVar : localVarNoParams)
+    {
+        SgSymbol* leftSymb = new SgSymbol(VARIABLE_NAME, localVar.c_str());
+        SgExpression* leftEx = new SgVarRefExp(leftSymb);
+        SgSymbol* rightSymb = renamedNewSymb(leftSymb, funcName);
+        SgExpression* rightEx = new SgVarRefExp(rightSymb);
+        ifLoadOk1->insertStmtAfter(*new SgAssignStmt(*leftEx, *rightEx), *ifLoadOk1);
+    }
+
+    //open all files
+    if (createdModuleForIO)
+    {
+        SgCallStmt* call = new SgCallStmt(*new SgSymbol(FUNCTION_NAME, iosNames[1].c_str()));
+        ifLoadOk1->insertStmtAfter(*call, *ifLoadOk1);
+    }
+
+    //READ LOCAL DATA
+    if (moduleStmts.size())
+    {
+        vector<SgExpression*> variablesVec;
+        vector<string> varNames;
+        for (auto localVar : localVarNoParams)
+        {
+            const char* varName = localVar.c_str();
+            char* varNameWithPref = mergedChar(funcName, varName);
+            SgSymbol* symbVar = new SgSymbol(VARIABLE_NAME, varNameWithPref);
+            SgExpression* exVar = new SgVarRefExp(symbVar);
+            variablesVec.push_back(exVar);
+
+            varNames.push_back(varNameWithPref);
+        }
+        auto dataRead = new SgInputOutputStmt(READ_STAT, unit, *makeExprList(variablesVec, false));
+        ifLoadOk1->insertStmtAfter(*dataRead, *ifLoadOk1);
+
+        chainLocalVarNoParams.push_back(varNames);
+    }
+
+    if (!isBaseFunc)
+    {
+        SgExpression* procLabelExpr = new SgVarRefExp(procLabelSymb);
+        auto labelRead = new SgInputOutputStmt(READ_STAT, unit, *procLabelExpr);
+        ifLoadOk1->insertStmtAfter(*labelRead, *ifLoadOk1);
+    }
+
+    //READ from modules
+    for (auto& mod : moduleNames)
+    {
+        SgCallStmt* call = new SgCallStmt(*new SgSymbol(FUNCTION_NAME, ("SPF_CP_" + mod).c_str()));
+        call->addArg(*new SgValueExp(unitNum));
+        call->addArg(*new SgValueExp(0));
+        ifLoadOk1->insertStmtAfter(*call, *ifLoadOk1);
+    }
+
+    //READ COMMON DATA
+    if (funcI->isMain)
+        if (commonVariables.size())
+        {
+            vector<SgExpression*> commanVariablesVec;
+            for (auto commanVar : commonVariables)
+            {
+                SgSymbol* symbCommon = new SgSymbol(VARIABLE_NAME, commanVar.c_str());
+                SgExpression* exCommon = new SgVarRefExp(symbCommon);
+                commanVariablesVec.push_back(exCommon);
+            }
+            auto commonDataRead = new SgInputOutputStmt(READ_STAT, unit, *makeExprList(commanVariablesVec, false));
+            ifLoadOk1->insertStmtAfter(*commonDataRead, *ifLoadOk1);
+        }
+
+    ifLoadOk1->insertStmtAfter(*profCallS->copyPtr(), *ifLoadOk1);
+
+    for (int z = insertToLoadS.size() - 1; z >= 0; --z)
+        loadBlock->insertStmtAfter(*insertToLoadS[z], *loadBlock);
+
+    for (int z = insertToifLoadOk.size() - 1; z >= 0; --z)
+        ifLoadOk->insertStmtAfter(*insertToifLoadOk[z], *ifLoadOk);
+
+    return loadBlock;
+}
+
+static SgSymbol* createLabel(const string namelabel, SgStatement*& proc_moduleF)
+{
+    SgSymbol* procLabelSymb = new SgSymbol(VARIABLE_NAME, namelabel.c_str(), SgTypeInt(), proc_moduleF);
+    SgExpression* procLabel0 = new SgValueExp(0);
+    vector<SgSymbol*> vecLabelSymb = { procLabelSymb };
+    vector<SgExpression*> vecLabel0 = { procLabel0 };
+    makeDeclaration(proc_moduleF, vecLabelSymb, &vecLabel0);
+
+    return procLabelSymb;
+}
+
+static SgStatement* createSaveBlock(const vector<SgSymbol*>& loadS, FuncInfo*& funcI, SgExpression* iostat, SgArrayRefExp* journal,
+    SgExpression& frmt, SgExpression& unit, SgSymbol* files, SgExpression* fileIdx, const int numOfFiles,
+    const vector<SgSymbol*>& profS, SgExpression& frmtProf, SgExpression& unitNull,
+    SgStatement* profCallS, SgStatement* profCallE, const set<string>& localVarNoParams,
+    const map<string, SgStatement*>& moduleStmts, const set<string>& commonVariables, bool createdModuleForIO,
+    const vector<string>& moduleNames, const int unitNum, const vector<vector<string>>& chainLocalVarNoParams,
+    const vector<string>& chainLabel)
+{
+    SgStatement* storeBlock = new SgStatement(IF_NODE);
+
+
+    vector<SgExpression*> listSpec;
+    listSpec.push_back(&SgAssignOp(*new SgKeywordValExp("form"), *new SgValueExp("unformatted")));
+    listSpec.push_back(&SgAssignOp(*new SgKeywordValExp("iostat"), *iostat));
+    listSpec.push_back(&SgAssignOp(*new SgKeywordValExp("file"), *new SgArrayRefExp(*files, *fileIdx)));
+    listSpec.push_back(&unit);
+
+    SgIOControlStmt* open = new SgIOControlStmt(OPEN_STAT, *makeExprList(listSpec, false));
+    storeBlock->insertStmtAfter(*open, *storeBlock);
+
+    SgIfStmt* ifStoreOk = new SgIfStmt(*iostat == *new SgValueExp(0));
+    open->insertStmtAfter(*ifStoreOk, *storeBlock);
+    ifStoreOk->insertStmtAfter(*new SgIfStmt(*fileIdx == *new SgValueExp(numOfFiles + 1), *new SgAssignStmt(*fileIdx, *new SgValueExp(1))), *ifStoreOk);
+    ifStoreOk->insertStmtAfter(*new SgAssignStmt(*fileIdx, *fileIdx + *new SgValueExp(1)), *ifStoreOk);
+    ifStoreOk->addComment(("! STORE DATA TO CHECKPOINT " + to_string(localVarNoParams.size() + commonVariables.size()) + " items\n").c_str());
+    
+    //commentArgs.clear();
+    vector<SgExpression*> commentArgs;
+    commentArgs.push_back(new SgValueExp(" SECONDS"));
+    commentArgs.push_back(&(*new SgVarRefExp(profS[1]) - *new SgVarRefExp(profS[0])));
+    commentArgs.push_back(new SgArrayRefExp(*files, *fileIdx));
+    commentArgs.push_back(new SgValueExp("SPF CHECKPOINT STORED TO "));
+
+    ifStoreOk->insertStmtAfter(*new SgInputOutputStmt(WRITE_STAT, *makeExprList({ &frmtProf, &unitNull }, false), *makeExprList(commentArgs, false)), *ifStoreOk);
+    ifStoreOk->insertStmtAfter(profCallE->copy(), *ifStoreOk);
+
+    SgStatement* assign = ifStoreOk->lexNext();
+
+    //open all files
+    if (createdModuleForIO)
+    {
+        SgCallStmt* call = new SgCallStmt(*new SgSymbol(FUNCTION_NAME, iosNames[1].c_str()));
+        ifStoreOk->insertStmtAfter(*call, *ifStoreOk);
+    }
+    //WRITE from modules
+    for (auto& mod : moduleNames)
+    {
+        SgCallStmt* call = new SgCallStmt(*new SgSymbol(FUNCTION_NAME, ("SPF_CP_" + mod).c_str()));
+        call->addArg(*new SgValueExp(unitNum));
+        call->addArg(*new SgValueExp(1));
+        ifStoreOk->insertStmtAfter(*call, *ifStoreOk);
+    }
+
+    //close and inc
+    if (createdModuleForIO)
+    {
+        SgCallStmt* call = new SgCallStmt(*new SgSymbol(FUNCTION_NAME, iosNames[2].c_str()));
+        ifStoreOk->insertStmtAfter(*call, *ifStoreOk);
+        call = new SgCallStmt(*new SgSymbol(FUNCTION_NAME, iosNames[0].c_str()));
+        ifStoreOk->insertStmtAfter(*call, *ifStoreOk);
+    }
+    
+    if (moduleStmts.size())
+    {
+        vector<SgExpression*> variablesVec;
+        for (auto localVar : localVarNoParams)
+        {
+            const char* varName = localVar.c_str();
+            char* varNameWithPref = mergedChar(funcI->funcName.c_str(), varName);
+            SgSymbol* symbVar = new SgSymbol(VARIABLE_NAME, varNameWithPref);
+            SgExpression* exVar = new SgVarRefExp(symbVar);
+            variablesVec.push_back(exVar);
+        }
+        auto dataWrite = new SgInputOutputStmt(WRITE_STAT, unit, *makeExprList(variablesVec, false));
+        ifStoreOk->insertStmtAfter(*dataWrite, *ifStoreOk);
+    }
+
+    for (size_t i = 0; i < chainLabel.size(); i++)
+    {
+        if (!chainLocalVarNoParams[i].empty())
+        {
+            vector<SgExpression*> variablesVec;
+            for (auto localVar : chainLocalVarNoParams[i])
+            {
+                const char* varNameWithPref = localVar.c_str();
+                SgSymbol* symbVar = new SgSymbol(VARIABLE_NAME, varNameWithPref);
+                SgExpression* exVar = new SgVarRefExp(symbVar);
+                variablesVec.push_back(exVar);
+            }
+            auto dataWrite = new SgInputOutputStmt(WRITE_STAT, unit, *makeExprList(variablesVec, false));
+            ifStoreOk->insertStmtAfter(*dataWrite, *ifStoreOk);
+        }
+
+        SgSymbol* procLabelSymb = new SgSymbol(VARIABLE_NAME, chainLabel[i].c_str());
+        SgExpression* procLabelExpr = new SgVarRefExp(procLabelSymb);
+        auto labelRead = new SgInputOutputStmt(WRITE_STAT, unit, *procLabelExpr);
+        ifStoreOk->insertStmtAfter(*labelRead, *ifStoreOk);
+    }
+    
+    
+    if (commonVariables.size())
+    {
+        vector<SgExpression*> commanVariablesVec;
+        for (auto commanVar : commonVariables)
+        {
+            SgSymbol* symbCommon = new SgSymbol(VARIABLE_NAME, commanVar.c_str());
+            SgExpression* exCommon = new SgVarRefExp(symbCommon);
+            commanVariablesVec.push_back(exCommon);
+        }
+        auto commonDataWrite = new SgInputOutputStmt(WRITE_STAT, unit, *makeExprList(commanVariablesVec, false));
+        ifStoreOk->insertStmtAfter(*commonDataWrite, *ifStoreOk);
+    }
+    
+
+    // insert copy_block
+    for (auto localVar : localVarNoParams)
+    {
+        SgSymbol* rightSymb = new SgSymbol(VARIABLE_NAME, localVar.c_str());
+        SgExpression* rightEx = new SgVarRefExp(rightSymb);
+        SgSymbol* leftSymb = renamedNewSymb(rightSymb, funcI->funcName.c_str());
+        SgExpression* leftEx = new SgVarRefExp(leftSymb);
+        ifStoreOk->insertStmtAfter(*new SgAssignStmt(*leftEx, *rightEx), *ifStoreOk);
+    }
+
+    listSpec.clear();
+    listSpec.push_back(&SgAssignOp(*new SgKeywordValExp("iostat"), *iostat));
+    listSpec.push_back(&SgAssignOp(*new SgKeywordValExp("file"), *journal));
+    listSpec.push_back(&unit);
+
+    SgIOControlStmt* openJ_new = new SgIOControlStmt(OPEN_STAT, *makeExprList(listSpec, false));
+
+    assign->insertStmtBefore(*new SgIOControlStmt(CLOSE_STAT, unit), *ifStoreOk);
+    assign->insertStmtBefore(*openJ_new, *ifStoreOk);
+    assign->insertStmtBefore(*new SgInputOutputStmt(WRITE_STAT, *makeExprList({ &frmt, &unit }, false), *fileIdx), *ifStoreOk);
+    assign->insertStmtBefore(*new SgIOControlStmt(CLOSE_STAT, unit), *ifStoreOk);
+
+    ifStoreOk->insertStmtAfter(profCallS->copy(), *ifStoreOk);
+
+    return storeBlock;
+}
+
+static void saveVarToModule(const set<string>& localVarNoParams, SgStatement* callPE, const char* funcName, 
+                            SgSymbol* procLabelSymb, const int labNum)
+{
+    for (auto localVar : localVarNoParams)
+    {
+        SgSymbol* rightSymb = new SgSymbol(VARIABLE_NAME, localVar.c_str());
+        SgExpression* rightEx = new SgVarRefExp(rightSymb);
+        SgSymbol* leftSymb = renamedNewSymb(rightSymb, funcName);
+        SgExpression* leftEx = new SgVarRefExp(leftSymb);
+        callPE->insertStmtBefore(*new SgAssignStmt(*leftEx, *rightEx), *callPE->controlParent());
+    }
+
+    SgExpression* procLabelExpr = new SgVarRefExp(procLabelSymb);
+    SgExpression* labNumExpr = new SgValueExp(labNum);
+    callPE->insertStmtBefore(*new SgAssignStmt(*procLabelExpr, *labNumExpr), *callPE->controlParent());
+}
+
+static void processAllCalls(SgStatement* firstExec, const string funcToName, const string funcFromName,
+                            SgStatement* gotoBlock, const set<string> localVarNoParams, SgSymbol* procLabelSymb)
+{
+    SgStatement* execStmt = firstExec;
+    while (execStmt && isSgExecutableStatement(execStmt))
+    {
+        if (execStmt->variant() == PROC_STAT && execStmt->symbol()->identifier() == funcToName) {
+            const int labNum = getNextFreeLabel();
+            auto nextPELabel = new SgLabel(labNum);
+            execStmt->setLabel(*nextPELabel);
+
+            SgStatement* gotoNextPE = new SgStatement(IF_NODE);
+            gotoNextPE->setExpression(0, *new SgVarRefExp(procLabelSymb) == *new SgValueExp(labNum));
+            gotoNextPE->insertStmtAfter(*new SgGotoStmt(*nextPELabel), *gotoNextPE);
+
+            gotoBlock->insertStmtBefore(*gotoNextPE, *gotoBlock);
+
+            saveVarToModule(localVarNoParams, execStmt, funcFromName.c_str(), procLabelSymb, labNum);
+        }
+
+        execStmt = execStmt->lexNext();
+    }
+}
+
+static void processInFuncParam(FuncInfo* funcI, set<string>& inFuncParam)
+{
+    for (int i = 0; i < funcI->funcParams.countOfPars; ++i)
+        if (funcI->funcParams.isArgIn(i) && !funcI->funcParams.isArgOut(i))
+            inFuncParam.insert(funcI->funcParams.identificators[i]);
+}
+
+static void processFunctionCallChain(SgStatement* func, const vector<FuncInfo*>& allFuncInfo, SgStatement* moduleF,
+                                     const vector<SgSymbol*>& loadS, SgExpression* iostat, SgArrayRefExp* journal, 
+                                     SgExpression& frmt, SgExpression& unit,
+                                     SgSymbol* files, SgExpression* fileIdx, const int every,
+                                     const int numOfFiles, const string additional, const vector<SgSymbol*> profS, 
+                                     SgExpression& frmtProf, SgExpression& unitNull, const int unitNum,
+                                     bool createdModuleForIO, const vector<string>& moduleNames, 
+                                     vector<vector<string>>& chainLocalVarNoParams, vector<string>& chainLabel)
+{
+    //find function structure
+    FuncInfo* funcI = findFileInfoByName(func, allFuncInfo);
+
+    set<pair<FuncInfo*, FuncInfo*>> toProcess;
+    fillToProcess(funcI, toProcess);
+
+    map<FuncInfo*, SgStatement*> processedFrom;
+    for (auto& pairs : toProcess)
+    {
+        FuncInfo* funcTo = pairs.first;
+        FuncInfo* funcFrom = pairs.second;
+
+        SgFile::switchToFile(funcFrom->fileName);
+
+        int callNum = 1;
+        SgStatement* hedrTo = funcTo->funcPointer->GetOriginal();
+        SgStatement* hedrFrom = funcFrom->funcPointer->GetOriginal();
+        SgStatement* lastDecl = hedrFrom->lexNext();
+        while (lastDecl && !isSgExecutableStatement(lastDecl->lexNext()))
+            lastDecl = lastDecl->lexNext();
+
+        SgStatement* firstExec = lastDecl->lexNext();
+        vector<SgExpression*> local;
+        map<string, SgStatement*> localParams;
+        set<string> addedToList;
+        //findLocalData(hedrFrom, firstExec, local, localParams, addedToList, allFuncInfo);
+
+        if (!processedFrom.count(funcFrom))
+        {
+            SgSymbol* timeF = new SgSymbol(FUNCTION_NAME, "omp_get_wtime", SgTypeDouble(), func); // OR dvtime        
+
+            SgStatement* profCallS = new SgAssignStmt(*new SgVarRefExp(profS[0]), *new SgFunctionCallExp(*timeF));
+            SgStatement* profCallE = new SgAssignStmt(*new SgVarRefExp(profS[1]), *new SgFunctionCallExp(*timeF));
+            
+            const string funcName = funcFrom->funcName;
+
+            SgStatement* proc_moduleF = NULL;
+            const string proc_cpModule = "spf_module_" + funcName;
+            createModule(proc_moduleF, proc_cpModule);
+            SgSymbol* proc_mainModuleCpS = proc_moduleF->symbol();
+
+            set<string> inFuncParam;
+            processInFuncParam(funcFrom, inFuncParam);
+
+            map<string, SgStatement*> moduleStmts;
+            map<string, SgStatement*> moduleParamStmts;
+            set<string> commonVariables;
+            set<string> externVars;
+            processVarBlock(hedrFrom, firstExec, moduleStmts, moduleParamStmts, commonVariables, externVars, funcFrom, inFuncParam);
+
+            set<string> addedModuleParams;
+            set<string> localVarNoParams;
+            insertStmtToModule(moduleStmts, moduleParamStmts, addedModuleParams, commonVariables, proc_moduleF, localVarNoParams, externVars);
+            //chainLocalVarNoParams.push_back(localVarNoParams);
+
+            const string namelabelSymb = funcFrom->funcName + "_label";
+            SgSymbol* procLabelSymb = createLabel(namelabelSymb, proc_moduleF);
+                
+            chainLabel.push_back(namelabelSymb);
+
+            hedrFrom->insertStmtAfter(*new SgStatement(USE_STMT, NULL, proc_mainModuleCpS), *hedrFrom);
+            
+            SgFile::switchToFile(func->fileName());
+            SgStatement* useModuleSt = new SgStatement(USE_STMT);
+            useModuleSt->setSymbol(*proc_mainModuleCpS);
+            func->insertStmtAfter(*useModuleSt, *func);
+
+            SgSymbol* modS = moduleF->symbol();
+            SgFile::switchToFile(funcFrom->fileName);
+            SgStatement* useSt = new SgStatement(USE_STMT);
+            useSt->setSymbol(*modS);
+            hedrFrom->insertStmtAfter(*useSt, *hedrFrom);
+
+
+            SgStatement* loadBlock = createLoadBlock(loadS, funcFrom, iostat, journal, frmt, unit, files, fileIdx,
+                                                     numOfFiles, profS, frmtProf, unitNull, profCallS, profCallE, 
+                                                     localVarNoParams, moduleStmts, commonVariables, createdModuleForIO, 
+                                                     moduleNames, unitNum, funcI->funcName, chainLocalVarNoParams, false, procLabelSymb);
+            firstExec->insertStmtBefore(*loadBlock, *firstExec->controlParent());
+            if (funcFrom->isMain)
+            {
+                insertInitNamesOfFiles(numOfFiles, additional, files, journal, lastDecl, false);
+                /*
+                
+                SgAssignStmt* loadOne = new SgAssignStmt(*new SgVarRefExp(loadS[0]), *new SgValueExp(1));
+                
+                vector<SgStatement*> insertToifLoadOk;
+                SgIfStmt* ifLoadOk = new SgIfStmt(*iostat == *new SgValueExp(0));
+
+                SgInputOutputStmt* read = new SgInputOutputStmt(READ_STAT, *makeExprList({ &frmt, &unit }, false), *fileIdx);
+                insertToifLoadOk.push_back(read);
+                insertToifLoadOk.push_back(new SgIOControlStmt(CLOSE_STAT, unit));
+                insertToifLoadOk.push_back(createOpen(iostat, files, fileIdx, unit));
+
+                read = new SgInputOutputStmt(READ_STAT, *makeExprList({ &frmt, &unit }, false), *new SgVarRefExp(loadS[3]));
+                SgIfStmt* ifLoadOk1 = new SgIfStmt(*iostat == *new SgValueExp(0), *read);
+                SgAssignStmt* loadZero = new SgAssignStmt(*new SgVarRefExp(loadS[0]), *new SgValueExp(0));
+                ifLoadOk1->insertStmtAfter(*loadZero, *ifLoadOk1);
+
+                insertToifLoadOk.push_back(ifLoadOk1);
+
+                firstExec->insertStmtBefore(*gotoBlock, *hedrFrom);
+
+                for (int z = insertToGotoBlock.size() - 1; z >= 0; --z)
+                    gotoBlock->insertStmtAfter(*insertToGotoBlock[z], *gotoBlock);
+
+                for (int z = insertToifLoadOk.size() - 1; z >= 0; --z)
+                    ifLoadOk->insertStmtAfter(*insertToifLoadOk[z], *ifLoadOk);
+                    */
+                //processedFrom[funcFrom] = ifLoadOk1->lexNext();
+            }
+
+            SgStatement* gotoBlock = new SgStatement(IF_NODE);
+            gotoBlock->addComment("! goto next program unit\n");
+            gotoBlock->setExpression(0, *new SgVarRefExp(loadS[4]) == *new SgValueExp(1));
+            firstExec->insertStmtBefore(*gotoBlock, *firstExec->controlParent());
+
+            // insert gotoBlock and save to module
+            processAllCalls(firstExec, funcTo->funcName, funcFrom->funcName, gotoBlock, localVarNoParams, procLabelSymb);
+
+            
+
+            /*
+            std::cout << funcTo->funcName << std::endl;
+            std::cout << "-------------------------------------" << std::endl;
+            for (int k = 0; k < funcTo->callsTo.size(); k++)
+            {
+                std::cout << funcTo->callsTo[k] << std::endl;
+            }
+            std::cout << "=====================================" << std::endl;
+
+            std::cout << "-------------------------------------" << std::endl;
+            for (auto elem :funcTo->callsFrom)
+            {
+                std::cout << elem << std::endl;
+            }
+            std::cout << "=====================================" << std::endl;
+            std::cout << funcFrom->funcName << std::endl;
+            std::cout << "-------------------------------------" << std::endl;
+            for (int k = 0; k < funcFrom->callsTo.size(); k++)
+            {
+                std::cout << funcFrom->callsTo[k] << std::endl;
+            }
+            std::cout << "=====================================" << std::endl;
+
+            std::cout << "-------------------------------------" << std::endl;
+            for (auto elem : funcFrom->callsFrom)
+            {
+                std::cout << elem << std::endl;
+            }
+            std::cout << "=====================================" << std::endl;
+            */
+            /*
+            SgStatement* gotoBlock = new SgStatement(IF_NODE);
+            vector<SgStatement*> insertToGotoBlock;
+
+            gotoBlock->addComment("!GOTO LOAD BLOCK \n");
+            gotoBlock->setExpression(0, *new SgVarRefExp(loadS[0]) == *new SgValueExp(0));
+
+            if (funcFrom->isMain)
+            {
+                SgAssignStmt* loadOne = new SgAssignStmt(*new SgVarRefExp(loadS[0]), *new SgValueExp(1));
+                insertToGotoBlock.push_back(loadOne);
+                insertToGotoBlock.push_back(createOpenJ_old(iostat, journal, unit));
+
+                vector<SgStatement*> insertToifLoadOk;
+                SgIfStmt* ifLoadOk = new SgIfStmt(*iostat == *new SgValueExp(0));
+                insertToGotoBlock.push_back(ifLoadOk);
+
+                SgInputOutputStmt* read = new SgInputOutputStmt(READ_STAT, *makeExprList({ &frmt, &unit }, false), *fileIdx);
+                insertToifLoadOk.push_back(read);
+                insertToifLoadOk.push_back(new SgIOControlStmt(CLOSE_STAT, unit));
+                insertToifLoadOk.push_back(createOpen(iostat, files, fileIdx, unit));
+
+                read = new SgInputOutputStmt(READ_STAT, *makeExprList({ &frmt, &unit }, false), *new SgVarRefExp(loadS[3]));
+                SgIfStmt* ifLoadOk1 = new SgIfStmt(*iostat == *new SgValueExp(0), *read);
+                SgAssignStmt* loadZero = new SgAssignStmt(*new SgVarRefExp(loadS[0]), *new SgValueExp(0));
+                ifLoadOk1->insertStmtAfter(*loadZero, *ifLoadOk1);
+
+                insertToifLoadOk.push_back(ifLoadOk1);
+
+                firstExec->insertStmtBefore(*gotoBlock, *hedrFrom);
+
+                for (int z = insertToGotoBlock.size() - 1; z >= 0; --z)
+                    gotoBlock->insertStmtAfter(*insertToGotoBlock[z], *gotoBlock);
+
+                for (int z = insertToifLoadOk.size() - 1; z >= 0; --z)
+                    ifLoadOk->insertStmtAfter(*insertToifLoadOk[z], *ifLoadOk);
+
+                processedFrom[funcFrom] = ifLoadOk1->lexNext();
+            }
+            else
+            {
+                SgStatement* read = new SgInputOutputStmt(READ_STAT, *makeExprList({ &frmt, &unit }, false), *new SgVarRefExp(loadS[3]));
+                gotoBlock->insertStmtAfter(*read, *gotoBlock);
+                processedFrom[funcFrom] = gotoBlock->lexNext();
+                firstExec->insertStmtBefore(*gotoBlock, *hedrFrom);
+            }*/
+        }
+        
+            /*
+        for (auto& callInfo : funcFrom->callsFromDetailed)
+        {
+            auto& call = callInfo.pointerDetailCallsFrom;
+            SgStatement* st = NULL;
+
+            if (isSgFuncHedrStmt(hedrTo) && call.second == FUNC_CALL)
+            {
+                SgFunctionCallExp* callExp = (SgFunctionCallExp*)call.first;
+                if (!strcmp(callExp->funName()->identifier(), funcTo->funcName.c_str()))
+                {
+                    st = SgStatement::getStatmentByExpression(callExp);
+                    SgSymbol* buf = new SgSymbol(VARIABLE_NAME, ("SPF_CALL_" + funcTo->funcName + "_" + to_string(callNum)).c_str(), callExp->type(), funcFrom->funcPointer->GetOriginal());
+                    SgExpression* bufRef = new SgVarRefExp(buf);
+                    SgStatement* bufAssign = new SgAssignStmt(*bufRef, *callExp);
+                    st->insertStmtBefore(*bufAssign, *(st->controlParent()));
+                    replaceExprByExprInSt(st, callExp, bufRef);
+                    makeDeclaration(hedrFrom, { buf });
+
+                    for (int i = 0; i < callExp->numberOfArgs(); i++)
+                    {
+                        if (funcTo->funcParams.isArgInOut(i) || funcTo->funcParams.isArgOut(i))
+                        {
+                            SgSymbol* s, * sl;
+                            SgStatement* lst = hedrTo->lastNodeOfStmt();
+                            sl = lst->lexNext() ? lst->lexNext()->symbol() : NULL;
+                            for (s = hedrTo->symbol(); s != sl && s; s = s->next())
+                            {
+                                if (s->scope() == hedrTo && !strcmp(s->identifier(), funcTo->funcParams.identificators[i].c_str()))
+                                {
+                                    break;
+                                }
+                            }
+
+                            SgSymbol* argBuf = new SgSymbol(VARIABLE_NAME, ("SPF_ARG_" + funcTo->funcName + "_" + to_string(callNum) + "_" + to_string(i)).c_str(), s->type(), funcFrom->funcPointer->GetOriginal());
+                            SgExpression* argBufRef = new SgVarRefExp(argBuf);
+                            SgStatement* argBufAssign = new SgAssignStmt(*argBufRef, *(callExp->arg(i)));
+                            bufAssign->insertStmtBefore(*argBufAssign, *(st->controlParent()));
+                            SgStatement* decl = makeDeclaration(hedrFrom, { argBuf });
+
+                            for (int i = 0; i < 3; i++)
+                            {
+                                SgExpression* e;
+                                if (e = decl->expr(i))
+                                    decl->setExpression(i, CalculateInteger(ReplaceConstant(e)));
+                            }
+
+                        }
+                    }
+                    st = bufAssign;
+                    callNum++;
+                }
+            }
+            else if (isSgProcHedrStmt(hedrTo) && call.second == PROC_STAT)
+            {
+                //TODO: need to revise!!
+                /*SgCallStmt* callSt = (SgCallStmt*)call.first;
+                if (!strcmp(callSt->name()->identifier(), funcTo->funcName.c_str())) {
+                    st = callSt;
+                    for (int i = 0; i < callSt->numberOfArgs(); i++)
+                    {
+                        if (funcTo->funcParams.isArgInOut(i) || funcTo->funcParams.isArgOut(i))
+                        {
+                            SgSymbol* buf1 = new SgSymbol(VARIABLE_NAME, "TEMP1", callSt->arg(i)->type(), hedrFrom);
+                            SgExpression* buf1Ref = new SgVarRefExp(buf1);
+                            SgStatement* buf1Assign = new SgAssignStmt(*buf1Ref, *(callSt->arg(i)));
+                            st->insertStmtBefore(*buf1Assign, *(st->controlParent()));
+                        }
+                    }
+                }
+            }
+
+            if (st)
+            {
+                SgStatement* loadBlock = new SgStatement(IF_NODE);
+                SgStatement* loadBlockLast = NULL;
+                SgStatement* storeBlock = new SgStatement(IF_NODE);
+
+                st->insertStmtBefore(*loadBlock, *st->controlParent());
+                st->insertStmtAfter(*storeBlock, *st->controlParent());
+
+                loadBlock->addComment("! LOAD CHECKPOINT\n");
+                const int labNum = getNextFreeLabel();
+                auto loadblockLab = new SgLabel(labNum);
+                loadBlock->setLabel(*loadblockLab);
+
+                SgIfStmt* gotoIf = new SgIfStmt(*new SgVarRefExp(loadS[3]) == *new SgValueExp(labNum), *new SgGotoStmt(*loadblockLab));
+                processedFrom[funcFrom]->insertStmtAfter(*gotoIf, *(processedFrom[funcFrom]->controlParent()));
+
+                storeBlock->addComment("! STORE CHECKPOINT\n");
+
+                //TODO: this block incorrect!!
+                storeBlock->setExpression(0, *new SgVarRefExp(everyS[0]) >= *new SgValueExp(every));
+
+                vector<SgStatement*> insertToLoadS;
+
+                loadBlock->setExpression(0, *new SgVarRefExp(loadS[0]) == *new SgValueExp(0));
+                loadBlock->addComment("! LOAD DATA FROM CHECKPOINT\n");
+
+                //READ DATA
+                if (local.size())
+                {
+                    auto dataRead = new SgInputOutputStmt(READ_STAT, unit, *makeExprList(local));
+                    loadBlock->insertStmtAfter(*dataRead, *loadBlock);
+                }
+            }
+        }
+        */
+    }
+
+
+    SgFile::switchToFile(func->fileName());
+}
+
+static void processModules(SgFile* file, const vector<FuncInfo*>& allFuncInfo)
+{
+    vector<SgStatement*> modules;
+    findModulesInFile(file, modules);
+    for (auto& mod : modules)
+    {
+        char pref[5];
+        strncpy(pref, mod->symbol()->identifier(), 4);
+        pref[4] = '\0';
+        if (!strcmp(pref, "spf_"))
+            continue;
+
+        bool hasContains = false;
+        SgStatement* st = mod->lexNext();
+        while (st != mod->lastNodeOfStmt() && !hasContains)
+        {
+            hasContains = st->variant() == CONTAINS_STMT;
+            st = st->lexNext();
+        }
+
+        vector<SgExpression*> local;
+        map<string, SgStatement*> localParams;
+        set<string> addedToList;
+        findLocalData(mod, hasContains ? st : mod->lastNodeOfStmt(), local, localParams, addedToList, allFuncInfo);
+
+        SgProcHedrStmt* newF = new SgProcHedrStmt((string("spf_cp_") + mod->symbol()->identifier()).c_str());
+        if (!hasContains)
+            mod->lastNodeOfStmt()->insertStmtBefore(*new SgStatement(CONTAINS_STMT), *mod);
+        mod->lastNodeOfStmt()->insertStmtBefore(*newF, *mod);
+
+        newF->AddArg("unit_f", *SgTypeInt());
+        newF->AddArg("type_of_op", *SgTypeInt());
+
+        if (local.size())
+        {
+            SgExpression& unit = SgAssignOp(*new SgKeywordValExp("unit"), *new SgVarRefExp(*newF->parameter(0)));
+            auto dataRead = new SgInputOutputStmt(READ_STAT, unit, *makeExprList(local));
+            auto dataWrite = new SgInputOutputStmt(WRITE_STAT, unit, *makeExprList(local));
+
+            SgIfStmt* ifBlock = new SgIfStmt(*new SgVarRefExp(*newF->parameter(1)) == *new SgValueExp(0), *dataRead, *dataWrite);
+            newF->lastNodeOfStmt()->insertStmtBefore(*ifBlock, *newF);
+
+            ifBlock->addComment(("!STORE OR LOAD " + to_string(local.size()) + " ITEMS\n").c_str());
+        }
+    }
+}
+
 void createCheckpoints(SgFile* file, const map<string, CommonBlock*>& commonBlocks, const map<int, UserFiles>& filesInfo,
                        const vector<FuncInfo*>& allFuncInfo)
 {
@@ -1071,7 +1547,6 @@ void createCheckpoints(SgFile* file, const map<string, CommonBlock*>& commonBloc
         checkNull(func, convertFileName(__FILE__).c_str(), __LINE__);
         checkNull(point, convertFileName(__FILE__).c_str(), __LINE__);
 
-        const int labNum = getNextFreeLabel();
         bool createdModuleForIO = createForIOs(filesInfo, func);
 
         SgStatement* lastDecl = func->lexNext();
@@ -1087,19 +1562,27 @@ void createCheckpoints(SgFile* file, const map<string, CommonBlock*>& commonBloc
         findLocalData(func, firstExec, local, localParams, addedToList, allFuncInfo);
 
         const char* funcName = func->symbol()->identifier();
-        int lenFuncName = strlen(funcName);
+        //int lenFuncName = strlen(funcName);
         
         SgStatement* proc_moduleF = NULL;
-        const string proc_cpModule = "spf_module_" + string(funcName);;
+        const string proc_cpModule = "spf_module_" + string(funcName);
         createModule(proc_moduleF, proc_cpModule);
         SgSymbol* proc_mainModuleCpS = proc_moduleF->symbol();
-        //SgStatement* endProcModuleF = proc_moduleF->lastNodeOfStmt();
-                
+
+        FuncInfo* funcI = findFileInfoByName(func, allFuncInfo);
+        set<string> intentInParams;
+        for (int i = 0; i < funcI->funcParams.countOfPars; ++i)
+            if (funcI->funcParams.isArgIn(i) && !funcI->funcParams.isArgOut(i))
+                intentInParams.insert(funcI->funcParams.identificators[i]);
+
+        set<string> inFuncParam;
+        processInFuncParam(funcI, inFuncParam);
+
         map<string, SgStatement*> moduleStmts;
         map<string, SgStatement*> moduleParamStmts;
         set<string> commonVariables;
         set<string> externVars;
-        processVarBlock(func, firstExec, moduleStmts, moduleParamStmts, commonVariables, externVars);
+        processVarBlock(func, firstExec, moduleStmts, moduleParamStmts, commonVariables, externVars, funcI, inFuncParam);
 
         set<string> addedModuleParams;
         set<string> localVarNoParams;
@@ -1107,16 +1590,6 @@ void createCheckpoints(SgFile* file, const map<string, CommonBlock*>& commonBloc
                 
         const vector<SgStatement*> useOfMods = findUseOfModules(func->lexNext(), firstExec);
 
-        SgStatement* loadBlock = new SgStatement(IF_NODE);
-        SgStatement* storeBlock = new SgStatement(IF_NODE);
-
-        firstExec->insertStmtBefore(*loadBlock, *firstExec->controlParent());
-        point->insertStmtBefore(*storeBlock, *point->controlParent());
-
-        loadBlock->addComment("! LOAD CHECKPOINT\n");
-        //auto loadblockLab = new SgLabel(labNum);
-        //loadBlock->setLabel(*loadblockLab);
-
         string filesS = "spf_cp_files" + additional;
         SgSymbol* files = new SgSymbol(VARIABLE_NAME, filesS.c_str(), createArrayCharType(32, numOfFiles + 1), func);
         SgArrayRefExp* journal = new SgArrayRefExp(*files, *new SgValueExp(numOfFiles + 1));
@@ -1124,9 +1597,9 @@ void createCheckpoints(SgFile* file, const map<string, CommonBlock*>& commonBloc
         //give max len, dont insert
         int maxFileLen = insertInitNamesOfFiles(numOfFiles, additional, files, journal, NULL);
 
-        vector<SgSymbol*> everyS;
+        //vector<SgSymbol*> everyS;
         vector<SgSymbol*> profS;
-        vector<SgExpression*> initS;
+        //vector<SgExpression*> initS;
 
         string profSs = "spf_cp_prof_s" + additional;
         string profEs = "spf_cp_prof_e" + additional;
@@ -1137,49 +1610,11 @@ void createCheckpoints(SgFile* file, const map<string, CommonBlock*>& commonBloc
 
         SgStatement* profCallS = new SgAssignStmt(*new SgVarRefExp(profS[0]), *new SgFunctionCallExp(*timeF));
         SgStatement* profCallE = new SgAssignStmt(*new SgVarRefExp(profS[1]), *new SgFunctionCallExp(*timeF));
-
-        if (type == typeEvery::TIME)
-        {
-            string everySs = "spf_cp_start" + additional;
-            string everyEs = "spf_cp_end" + additional;
-            everyS.push_back(new SgSymbol(VARIABLE_NAME, everySs.c_str(), SgTypeFloat(), func));
-            everyS.push_back(new SgSymbol(VARIABLE_NAME, everyEs.c_str(), SgTypeFloat(), func));
-
-            initS.push_back(NULL);
-            initS.push_back(NULL);
-
-            SgStatement* call = new SgAssignStmt(*new SgVarRefExp(everyS[0]), *new SgFunctionCallExp(*timeF));
-            lastDecl->insertStmtAfter(*call, *func);
-            lastDecl->insertStmtAfter(*new SgStatement(DVM_BARRIER_DIR), *func);
-
-            storeBlock->insertStmtAfter(call->copy(), *storeBlock);
-            storeBlock->insertStmtAfter(*new SgStatement(DVM_BARRIER_DIR), *storeBlock);
-
-            call = new SgAssignStmt(*new SgVarRefExp(everyS[1]), *new SgFunctionCallExp(*timeF));
-            storeBlock->insertStmtBefore(*new SgStatement(DVM_BARRIER_DIR), *storeBlock->controlParent());
-            storeBlock->insertStmtBefore(*call, *storeBlock->controlParent());
-            call->lexPrev()->addComment("! STORE CHECKPOINT\n");
-
-            storeBlock->setExpression(0, *new SgVarRefExp(everyS[1]) - *new SgVarRefExp(everyS[0]) >= *new SgValueExp(every));
-        }
-        else if (type == typeEvery::ITER)
-        {
-            string everyIs = "spf_cp_interval" + additional;
-            everyS.push_back(new SgSymbol(VARIABLE_NAME, everyIs.c_str(), SgTypeInt(), func));
-            initS.push_back(new SgValueExp(0));
-            SgAssignStmt* init = new SgAssignStmt(*new SgVarRefExp(everyS[0]), *new SgValueExp(0));
-            storeBlock->insertStmtAfter(*init, *storeBlock);
-
-            SgAssignStmt* inc = new SgAssignStmt(*new SgVarRefExp(everyS[0]), *new SgVarRefExp(everyS[0]) + *new SgValueExp(1));
-            storeBlock->insertStmtBefore(*inc, *storeBlock->controlParent());
-            inc->addComment("! STORE CHECKPOINT\n");
-
-            storeBlock->setExpression(0, *new SgVarRefExp(everyS[0]) >= *new SgValueExp(every));
-        }
-
+        /*
+        
+        */
         vector<SgSymbol*> loadS;
         vector<SgExpression*> initLoadS;
-        vector<SgStatement*> insertToLoadS;
 
         string cpLoadS = "spf_cp_load" + additional;
         loadS.push_back(new SgSymbol(VARIABLE_NAME, cpLoadS.c_str(), SgTypeInt(), func));
@@ -1209,12 +1644,7 @@ void createCheckpoints(SgFile* file, const map<string, CommonBlock*>& commonBloc
         loadS.push_back(new SgSymbol(VARIABLE_NAME, saveFS.c_str(), SgTypeInt(), func));
         initLoadS.push_back(new SgValueExp(0));
 
-        loadBlock->setExpression(0, *new SgVarRefExp(loadS[4]) == *new SgValueExp(1)); //*new SgVarRefExp(loadS[0])
-        SgAssignStmt* init = new SgAssignStmt(*new SgVarRefExp(loadS[4]), *new SgValueExp(0));
-        insertToLoadS.push_back(init);
-
-
-
+        
         SgExpression& unitNull = SgAssignOp(*new SgKeywordValExp("unit"), *new SgKeywordValExp("*"));
         SgExpression& unit = SgAssignOp(*new SgKeywordValExp("unit"), *new SgValueExp(unitNum));
         SgExpression& frmt = SgAssignOp(*new SgKeywordValExp("fmt"), *new SgKeywordValExp("*"));
@@ -1224,217 +1654,19 @@ void createCheckpoints(SgFile* file, const map<string, CommonBlock*>& commonBloc
         SgExpression* iostat = new SgVarRefExp(loadS[2]);
         SgExpression* fileIdx = new SgVarRefExp(loadS[1]);
 
-        insertToLoadS.push_back(createOpenJ_old(iostat, journal, unit));
+        vector<vector<string>> chainLocalVarNoParamsa;
+        SgStatement* loadBlock = createLoadBlock(loadS, funcI, iostat, journal, frmt, unit, files, fileIdx, 
+                                                 numOfFiles, profS, frmtProf, unitNull, profCallS, profCallE, localVarNoParams, moduleStmts,
+                                                 commonVariables, createdModuleForIO, moduleNames, unitNum, funcName, chainLocalVarNoParamsa);
+        lastDecl->insertStmtAfter(*loadBlock, *lastDecl->controlParent());
 
-        vector<SgStatement*> insertToifLoadOk;
-        SgIfStmt* ifLoadOk = new SgIfStmt(*iostat == *new SgValueExp(0));
-        insertToLoadS.push_back(ifLoadOk);
 
-        SgInputOutputStmt* read = new SgInputOutputStmt(READ_STAT, *makeExprList({ &frmt, &unit }, false), *fileIdx); //*makeExprList({ fileIdx, labelIdx })
-        insertToifLoadOk.push_back(read);
-        insertToifLoadOk.push_back(new SgIOControlStmt(CLOSE_STAT, unit));
-        insertToifLoadOk.push_back(createOpen(iostat, files, fileIdx, unit));
 
-        SgIfStmt* ifLoadOk1 = new SgIfStmt(*iostat == *new SgValueExp(0)); //, *new SgIOControlStmt(CLOSE_STAT, unit)
+        if (funcI->isMain) {
+            insertInitNamesOfFiles(numOfFiles, additional, files, journal, lastDecl, false);
+        }
 
-        insertToifLoadOk.push_back(ifLoadOk1);
-
-        auto nextStLab = new SgLabel(labNum);
-        ifLoadOk1->insertStmtAfter(*new SgGotoStmt(*nextStLab), *ifLoadOk1);
-        point->setLabel(*nextStLab);
-
-        ifLoadOk1->insertStmtAfter(*new SgIOControlStmt(CLOSE_STAT, unit), *ifLoadOk1);
-
-        ifLoadOk1->insertStmtAfter(*new SgIfStmt(*fileIdx == *new SgValueExp(numOfFiles + 1), *new SgAssignStmt(*fileIdx, *new SgValueExp(1))), *ifLoadOk1);
-        ifLoadOk1->insertStmtAfter(*new SgAssignStmt(*fileIdx, *fileIdx + *new SgValueExp(1)), *ifLoadOk1);
-        ifLoadOk1->addComment("! LOAD DATA FROM CHECKPOINT\n"); // program sleep (frozed) here
-
-        vector<SgExpression*> commentArgs;
-        commentArgs.push_back(new SgValueExp(" SECONDS"));
-        commentArgs.push_back(&(*new SgVarRefExp(profS[1]) - *new SgVarRefExp(profS[0])));
-        commentArgs.push_back(new SgArrayRefExp(*files, *fileIdx));
-        commentArgs.push_back(new SgValueExp("SPF CHECKPOINT LOADED FROM "));
         
-        ifLoadOk1->insertStmtAfter(*new SgInputOutputStmt(WRITE_STAT, *makeExprList({ &frmtProf, &unitNull }, false), *makeExprList(commentArgs, false)), *ifLoadOk1);
-        ifLoadOk1->insertStmtAfter(profCallE->copy(), *ifLoadOk1);
-
-        // insert copy_block
-        for (auto localVar : localVarNoParams)
-        {
-            SgSymbol* leftSymb = new SgSymbol(VARIABLE_NAME, localVar.c_str());
-            SgExpression* leftEx = new SgVarRefExp(leftSymb);
-            SgSymbol* rightSymb = renamedNewSymb(leftSymb, funcName);
-            SgExpression* rightEx = new SgVarRefExp(rightSymb);
-            ifLoadOk1->insertStmtAfter(*new SgAssignStmt(*leftEx, *rightEx), *ifLoadOk1);
-        }
-        
-        //open all files
-        if (createdModuleForIO)
-        {
-            SgCallStmt* call = new SgCallStmt(*new SgSymbol(FUNCTION_NAME, iosNames[1].c_str()));
-            ifLoadOk1->insertStmtAfter(*call, *ifLoadOk1);
-        }
-
-        //READ LOCAL DATA
-        vector<SgExpression*> variablesVec;
-        if (moduleStmts.size())
-        {
-            for (auto localVar : localVarNoParams)
-            {
-                const char* varName = localVar.c_str();
-                char* varNameWithPref = mergedChar(funcName, varName);
-                SgSymbol* symbVar = new SgSymbol(VARIABLE_NAME, varNameWithPref);
-                SgExpression* exVar = new SgVarRefExp(symbVar);
-                variablesVec.push_back(exVar);
-            }
-            auto dataRead = new SgInputOutputStmt(READ_STAT, unit, *makeExprList(variablesVec, false));
-            ifLoadOk1->insertStmtAfter(*dataRead, *ifLoadOk1);
-        }
-
-        //READ from modules
-        for (auto& mod : moduleNames)
-        {
-            SgCallStmt* call = new SgCallStmt(*new SgSymbol(FUNCTION_NAME, ("SPF_CP_" + mod).c_str()));
-            call->addArg(*new SgValueExp(unitNum));
-            call->addArg(*new SgValueExp(0));
-            ifLoadOk1->insertStmtAfter(*call, *ifLoadOk1);
-        }
-
-        //READ COMMON DATA
-        vector<SgExpression*> commanVariablesVec;
-        if (commonVariables.size())
-        {
-            for (auto commanVar : commonVariables)
-            {
-                SgSymbol* symbCommon = new SgSymbol(VARIABLE_NAME, commanVar.c_str());
-                SgExpression* exCommon = new SgVarRefExp(symbCommon);
-                commanVariablesVec.push_back(exCommon);
-            }
-            auto commonDataRead = new SgInputOutputStmt(READ_STAT, unit, *makeExprList(commanVariablesVec, false));
-            ifLoadOk1->insertStmtAfter(*commonDataRead, *ifLoadOk1);
-        }
-
-        /*
-        if (local.size())
-        {
-            auto dataRead = new SgInputOutputStmt(READ_STAT, unit, *makeExprList(local, false));
-            ifLoadOk1->insertStmtAfter(*dataRead, *ifLoadOk1);
-        } */
-
-        ifLoadOk1->insertStmtAfter(profCallS->copy(), *ifLoadOk1);
-
-        vector<SgExpression*> listSpec;
-        listSpec.push_back(&SgAssignOp(*new SgKeywordValExp("form"), *new SgValueExp("unformatted")));
-        listSpec.push_back(&SgAssignOp(*new SgKeywordValExp("iostat"), *iostat));
-        listSpec.push_back(&SgAssignOp(*new SgKeywordValExp("file"), *new SgArrayRefExp(*files, *fileIdx)));
-        listSpec.push_back(&unit);
-
-        SgIOControlStmt* open = new SgIOControlStmt(OPEN_STAT, *makeExprList(listSpec, false));
-        storeBlock->insertStmtAfter(*open, *storeBlock);
-
-        SgIfStmt* ifStoreOk = new SgIfStmt(*iostat == *new SgValueExp(0));
-        open->insertStmtAfter(*ifStoreOk, *storeBlock);
-        ifStoreOk->insertStmtAfter(*new SgIfStmt(*fileIdx == *new SgValueExp(numOfFiles + 1), *new SgAssignStmt(*fileIdx, *new SgValueExp(1))), *ifStoreOk);
-        ifStoreOk->insertStmtAfter(*new SgAssignStmt(*fileIdx, *fileIdx + *new SgValueExp(1)), *ifStoreOk);
-        ifStoreOk->addComment(("! STORE DATA TO CHECKPOINT " + to_string(local.size()) + " items\n").c_str());
-
-        commentArgs.clear();
-        commentArgs.push_back(new SgValueExp(" SECONDS"));
-        commentArgs.push_back(&(*new SgVarRefExp(profS[1]) - *new SgVarRefExp(profS[0])));
-        commentArgs.push_back(new SgArrayRefExp(*files, *fileIdx));
-        commentArgs.push_back(new SgValueExp("SPF CHECKPOINT STORED TO "));
-
-        ifStoreOk->insertStmtAfter(*new SgInputOutputStmt(WRITE_STAT, *makeExprList({ &frmtProf, &unitNull }, false), *makeExprList(commentArgs, false)), *ifStoreOk);
-        ifStoreOk->insertStmtAfter(profCallE->copy(), *ifStoreOk);
-
-        SgStatement* assign = ifStoreOk->lexNext();
-
-        //open all files
-        if (createdModuleForIO)
-        {
-            SgCallStmt* call = new SgCallStmt(*new SgSymbol(FUNCTION_NAME, iosNames[1].c_str()));
-            ifStoreOk->insertStmtAfter(*call, *ifStoreOk);
-        }
-        //WRITE from modules
-        for (auto& mod : moduleNames)
-        {
-            SgCallStmt* call = new SgCallStmt(*new SgSymbol(FUNCTION_NAME, ("SPF_CP_" + mod).c_str()));
-            call->addArg(*new SgValueExp(unitNum));
-            call->addArg(*new SgValueExp(1));
-            ifStoreOk->insertStmtAfter(*call, *ifStoreOk);
-        }
-
-        //close and inc
-        if (createdModuleForIO)
-        {
-            SgCallStmt* call = new SgCallStmt(*new SgSymbol(FUNCTION_NAME, iosNames[2].c_str()));
-            ifStoreOk->insertStmtAfter(*call, *ifStoreOk);
-            call = new SgCallStmt(*new SgSymbol(FUNCTION_NAME, iosNames[0].c_str()));
-            ifStoreOk->insertStmtAfter(*call, *ifStoreOk);
-        }
-
-        //WRITE DATA
-        if (variablesVec.size())
-        {
-            auto dataWrite = new SgInputOutputStmt(WRITE_STAT, unit, *makeExprList(variablesVec, false));
-            ifStoreOk->insertStmtAfter(*dataWrite, *ifStoreOk);
-        }
-
-        if (commanVariablesVec.size())
-        {
-            auto commonDataWrite = new SgInputOutputStmt(WRITE_STAT, unit, *makeExprList(commanVariablesVec, false));
-            ifStoreOk->insertStmtAfter(*commonDataWrite, *ifStoreOk);
-        }
-
-
-        // insert copy_block
-        for (auto localVar : localVarNoParams)
-        {
-            SgSymbol* rightSymb = new SgSymbol(VARIABLE_NAME, localVar.c_str());
-            SgExpression* rightEx = new SgVarRefExp(rightSymb);
-            SgSymbol* leftSymb = renamedNewSymb(rightSymb, funcName);
-            SgExpression* leftEx = new SgVarRefExp(leftSymb);
-            ifStoreOk->insertStmtAfter(*new SgAssignStmt(*leftEx, *rightEx), *ifStoreOk);
-        }
-        /*
-        if (local.size())
-        {
-            SgStatement* dataWrite = new SgInputOutputStmt(WRITE_STAT, unit, *makeExprList(local, false));
-            ifStoreOk->insertStmtAfter(*dataWrite, *ifStoreOk);
-        }
-        */
-        listSpec.clear();
-        listSpec.push_back(&SgAssignOp(*new SgKeywordValExp("iostat"), *iostat));
-        listSpec.push_back(&SgAssignOp(*new SgKeywordValExp("file"), *journal));
-        listSpec.push_back(&unit);
-
-        SgIOControlStmt* openJ_new = new SgIOControlStmt(OPEN_STAT, *makeExprList(listSpec, false));
-
-        assign->insertStmtBefore(*new SgIOControlStmt(CLOSE_STAT, unit), *ifStoreOk);
-        assign->insertStmtBefore(*openJ_new, *ifStoreOk);
-        assign->insertStmtBefore(*new SgInputOutputStmt(WRITE_STAT, *makeExprList({ &frmt, &unit }, false), *fileIdx), *ifStoreOk);
-        assign->insertStmtBefore(*new SgIOControlStmt(CLOSE_STAT, unit), *ifStoreOk);
-
-        ifStoreOk->insertStmtAfter(profCallS->copy(), *ifStoreOk);
-
-
-        insertInitNamesOfFiles(numOfFiles, additional, files, journal, lastDecl, false);
-        /*
-        SgStatement* timeFStmt = new SgStatement(VAR_DECL);
-        timeFStmt->setSymbol(*timeF);
-
-        SgExpression* timeFExpr = new SgExpression(VAR_REF);
-        timeFStmt->setExpression(0, timeFExpr);
-
-        SgExpression* typeExpr = new SgExpression(DOUBLE_VAL);
-        timeFStmt->setExpression(1, typeExpr);
-        lastDecl->insertStmtBefore(*timeFStmt, *lastDecl->controlParent()); */
-
-        for (int z = insertToLoadS.size() - 1; z >= 0; --z)
-            loadBlock->insertStmtAfter(*insertToLoadS[z], *loadBlock);
-
-        for (int z = insertToifLoadOk.size() - 1; z >= 0; --z)
-            ifLoadOk->insertStmtAfter(*insertToifLoadOk[z], *ifLoadOk);
 
 
         //TODO:
@@ -1448,7 +1680,7 @@ void createCheckpoints(SgFile* file, const map<string, CommonBlock*>& commonBloc
             printf("%s\n", elem.c_str());*/
 
             // make all new declarations
-        makeDeclaration(moduleF, everyS, &initS);
+        //makeDeclaration(moduleF, everyS, &initS);
         makeDeclaration(moduleF, loadS, &initLoadS);
         makeDeclaration(moduleF, profS);
         makeDeclaration(moduleF, { files });
@@ -1508,9 +1740,73 @@ void createCheckpoints(SgFile* file, const map<string, CommonBlock*>& commonBloc
                 func->insertStmtAfter(*use, *func);
             }
         }
+        
+        vector<SgSymbol*> everyS;
+        vector<SgExpression*> initS;
+        vector<vector<string>> chainLocalVarNoParams; //localVarNoParams
+        vector<string> chainLabel;
 
         //TODO: this function needs to be completely rewritten!!
-        //processFunctionCallChain(func, allFuncInfo, moduleF, loadS, iostat, journal, frmt, unit, files, fileIdx, every, everyS);
+        processFunctionCallChain(func, allFuncInfo, moduleF, loadS, iostat, journal, frmt, unit, files, fileIdx, every, numOfFiles, additional,
+                                 profS, frmtProf, unitNull, unitNum, createdModuleForIO, moduleNames, chainLocalVarNoParams, chainLabel);
+        
+        SgStatement* storeBlock = createSaveBlock(loadS, funcI, iostat, journal, frmt, unit, files, fileIdx,
+                                                  numOfFiles, profS, frmtProf, unitNull, profCallS, profCallE, localVarNoParams, moduleStmts,
+                                                  commonVariables, createdModuleForIO, moduleNames, unitNum, chainLocalVarNoParams, chainLabel);
+
+        point->insertStmtBefore(*storeBlock, *point->controlParent());
+
+        if (type == typeEvery::TIME)
+        {
+            string everySs = "spf_cp_start" + additional;
+            string everyEs = "spf_cp_end" + additional;
+            everyS.push_back(new SgSymbol(VARIABLE_NAME, everySs.c_str(), SgTypeFloat(), func));
+            everyS.push_back(new SgSymbol(VARIABLE_NAME, everyEs.c_str(), SgTypeFloat(), func));
+
+            initS.push_back(NULL);
+            initS.push_back(NULL);
+
+            SgStatement* call = new SgAssignStmt(*new SgVarRefExp(everyS[0]), *new SgFunctionCallExp(*timeF));
+            lastDecl->insertStmtAfter(*call, *func);
+            lastDecl->insertStmtAfter(*new SgStatement(DVM_BARRIER_DIR), *func);
+
+            storeBlock->insertStmtAfter(call->copy(), *storeBlock);
+            storeBlock->insertStmtAfter(*new SgStatement(DVM_BARRIER_DIR), *storeBlock);
+
+            call = new SgAssignStmt(*new SgVarRefExp(everyS[1]), *new SgFunctionCallExp(*timeF));
+            storeBlock->insertStmtBefore(*new SgStatement(DVM_BARRIER_DIR), *storeBlock->controlParent());
+            storeBlock->insertStmtBefore(*call, *storeBlock->controlParent());
+            call->lexPrev()->addComment("! STORE CHECKPOINT\n");
+
+            storeBlock->setExpression(0, *new SgVarRefExp(everyS[1]) - *new SgVarRefExp(everyS[0]) >= *new SgValueExp(every));
+        }
+        else if (type == typeEvery::ITER)
+        {
+            string everyIs = "spf_cp_interval" + additional;
+            everyS.push_back(new SgSymbol(VARIABLE_NAME, everyIs.c_str(), SgTypeInt(), func));
+            initS.push_back(new SgValueExp(0));
+            SgAssignStmt* init = new SgAssignStmt(*new SgVarRefExp(everyS[0]), *new SgValueExp(0));
+            storeBlock->insertStmtAfter(*init, *storeBlock);
+
+            SgAssignStmt* inc = new SgAssignStmt(*new SgVarRefExp(everyS[0]), *new SgVarRefExp(everyS[0]) + *new SgValueExp(1));
+            storeBlock->insertStmtBefore(*inc, *storeBlock->controlParent());
+            inc->addComment("! STORE CHECKPOINT\n");
+
+            storeBlock->setExpression(0, *new SgVarRefExp(everyS[0]) >= *new SgValueExp(every));
+        }
+
+        const int labNum = getNextFreeLabel();
+        auto nextStLab = new SgLabel(labNum);
+        point->setLabel(*nextStLab);
+
+        SgStatement* gotoBlock = new SgStatement(IF_NODE);
+        gotoBlock->addComment("! goto CP\n");
+        gotoBlock->setExpression(0, *new SgVarRefExp(loadS[4]) == *new SgValueExp(labNum));
+
+        gotoBlock->insertStmtAfter(*new SgGotoStmt(*nextStLab), *gotoBlock);
+        SgAssignStmt* init = new SgAssignStmt(*new SgVarRefExp(loadS[4]), *new SgValueExp(0));
+        gotoBlock->insertStmtAfter(*init, *gotoBlock);
+        loadBlock->insertStmtAfter(*gotoBlock, *loadBlock->controlParent());
     }
 
     processModules(file, allFuncInfo);