Куча была повреждена и прочие радости

// ConsoleApplication11.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
 
using namespace std;
 
int b1,     ///
    b2,     ///possible b-coefficient values
    b3,     ///
    cb = 5; //current b-coefficient
 
unsigned long filesize(const char* FullPath);
string bin(int DecNumber);
int dec(string BinNumber);
int getcb(int b_coeff_code);
 
int main(int argc, char* argv[])
{
    //argv[1] - Container path
    //argv[2] - inf-file path
    //argv[3] - b mode
    //argv[4] - out file path
 
    string n = "C:\\AZ\\ft1.bmp";
 
#pragma region /REGION/
    int i;  //counter
    char* impath = "C:\\AZ\\22802_7320c86e0504dccb6e2bdb709c0986a0.bmp";    //container path
    int size0 = filesize(impath);   //getting container size
    unsigned char *source = new unsigned char[size0];   //container byte array
    ifstream imfile(impath, ios::binary);
    for (i = 0; i < size0; i++) //filling container array
    {
        *(source + i) = imfile.get();
    }
    imfile.close();
    char* flpath = "C:\\AZ\\ft1.bmp";   //inf-file path
    union
    {
        unsigned long num;
        unsigned char bin[4];
    } size1;
    size1.num = filesize(flpath);   //getting inf-file size
    unsigned char *m = new unsigned char[size1.num];    //inf-file byte array
    ifstream infile(flpath, ios::binary);
    for (i = 0; i < size1.num; i++) //filling inf-file array
    {
        *(m + i) = infile.get();
    }
    infile.close();
#pragma region /REGION/
    string bm = "3";    //b-coefficient code
    int b,      //b-coefficient
        imcsize,    //container cluster size
        flcsize;    //inf-file cluster size
 
    if (bm == "1")
    {
        b = 1;
        bm = "001";
        imcsize = 8;
        flcsize = 1;
    }
    if (bm == "2")
    {
        b = 2;
        bm = "011";
        imcsize = 4;
        flcsize = 1;
    }
    if (bm == "3")
    {
        b = 4;
        bm = "111";
        imcsize = 2;
        flcsize = 1;
    }
 
    if (bm == "4")
    {
        b = 10;
        bm = "000";
        imcsize = 16;
        flcsize = 1;
    }
    if (bm == "5")
    {
        b = 21;
        bm = "010";
        imcsize = 16;
        flcsize = 3;
    }
    if (bm == "6")
    {
        b = 42;
        bm = "101";
        imcsize = 8;
        flcsize = 3;
    }
 
    if (bm == "7")
    {
        b = 210;
        bm = "100";
        imcsize = 24;
        flcsize = 3;
    }
    if (bm == "8")
    {
        b = 421;
        bm = "110";
        imcsize = 24;
        flcsize = 7;
    }
#pragma endregion Working with b-coefficient
    int width = 0,  //bmp image width (pixels)
        height = 0; //bmp image height (pixels)
    for (i = 0; i < 4; i++)
    {
        width += *(source + 18 + i)*pow(16.0, i * 2);
        height += *(source + 22 + i)*pow(16.0, i * 2);
    }
    int c1 = 0,                 //counter 1
        c2 = 4,                 //counter 2
        c3 = bm.length() - 1;   //counter 3
    char ext[4];
    do  //getting inf-file extention
    {
        if (c1 < 5)
            ext[c2] = flpath[c3];
        c2--;
        c3--;
        c1++;
    } while (flpath[c3] != '.');
    int rst = *(source + 10),       //first raster byte in container
        bpp = *(source + 28),       //number of bits per each pixel
        llb = width*bpp / 8,    //number of image bytes in eash container string
        lgb;                    //number of garbage butes in each container string
    unsigned char *v = new unsigned char[llb*height];   //array of raster bytes
    if (llb % 4 != 0) { lgb = 4 - llb % 4; }
    else { lgb = 0; }
    for (i = 0; i < height; i++)    //filling raster array
    {
        for (c2 = 0; c2 < llb; c2++)
        {
            *(v + i*llb + c2) = *(source + rst + i*(llb + lgb) + c2);
        }
    }
    int *gs = new int;
    if (lgb != 0) *gs = lgb*height;
    else *gs = 1;
    unsigned char *g = new unsigned char[*gs];  //array of garbage bytes
    for (i = 0; i < *gs; i++) { g[i] = dec("00000000"); }
#pragma region /REGION/
    unsigned char header[9];    //information about inf-file
    for (i = 0; i < 4; i++)     //size
    {
        header[i] = size1.bin[i];
    }
    for (i = 0; i < 5; i++)     //extention
    {
        header[i + 4] = ext[i];
    }
    unsigned char *f = new unsigned char[size1.num + 9];    //array of garbage bytes
    for (i = 0; i < 9; i++) { f[i] = header[i]; }
    for (i = 0; i < size1.num; i++) { f[i + 9] = m[i]; }
#pragma endregion Working with header
#pragma endregion Getting needed information
#pragma region /REGION/
    #pragma region /REGION/
    int s0;
    if (size1.num <= (llb*height - 3) / imcsize * flcsize) { s0 = size1.num / flcsize; }
    else { s0 = size0 / imcsize; }
    unsigned char   *imcluster = new unsigned char[imcsize];    //image cluster (bytes)
    unsigned char   *flclusterb = new unsigned char[flcsize * 8];   //inf-file cluster (bits)
    c1 = 3; //for reading image bytes
    c3 = 0; //for reading inf-file bytes
    unsigned long   c4 = 0, //counter 4
                    c5 = 0; //counter 5
    string  imcsb,  //string expression of one byte from image cluster
            flcsb;  //string expression of one byte from inf file cluster
#pragma endregion Preparations
    for (i = 0; i < s0; i++)
    {
        for (int j = 0; j < imcsize; j++) { *(imcluster + j) = *(v + c1); c1++; }   //getting image cluster (bytes)
        for (int j = 0; j < flcsize; j++)   //getting inf-file cluster (bits)
        {
            flcsb = bin(*(f + c3));
            for (int j = 0; j < flcsize * 8; j++)
            {
                for (int k = 0; k < 8; k++)
                {
                    flclusterb[c4] = flcsb[k];
                    c4++;
                }
            }
            c3++;
        }
        cb = getcb(b);  //getting current b-coefficient value
        c4 = 0;
        if (cb == 0) { c5++; continue; }
        for (int j = 0; j < imcsize; j++)   //modifying image cluster
        {
            imcsb = bin(*(imcluster + c5));
            for (int k = 8 - b; k < 8; k++)
            {
                imcsb[k] = *(flclusterb + c4);
                c4++;
            }
            *(imcluster + c5) = dec(imcsb);
            c5++;
        }
        for (int j = c1 - imcsize; j < c1; j++) //rewriting image cluster
        {
            *(v + j) = imcluster[j - c1 + imcsize];
        }
        c4 = 0;
        c5 = 0;
        if (i % 1000 == 0)
        {
            system("cls");
            cout << i/1000 << "K / " << s0;
        }
    }
    if ((size1.num < (llb * height - 3) / imcsize * flcsize) && (size1.num % flcsize != 0))
        for (i = 0; i < size1.num - size1.num / flcsize * flcsize; i++)
        {
            flcsb = bin(*(f + c3));
            for (int j = 0; j < 4; j++) { *(imcluster + j) = *(v + c1); c1++; } //getting image cluster (bytes)
            for (int j = 0; j < 4; j++)
            {
                imcsb = bin(*(imcluster + j));
                for (int k = 6; k < 8; k++)
                {
                    imcsb[k] = flcsb[c4];
                    c4++;
                }
            }
            for (int j = c1 - 4; j < c1; j++)   //rewriting image cluster
            {
                *(v + j) = imcluster[j - c1 + 4];
            }
            c4 = 0;
            c5 = 0;
        }
    if (size1.num > (llb * height - 3) / imcsize * flcsize)
        for (i = 0; i < size1.num - size0 / imcsize * flcsize; i++) { g[i] = *(f + c3); c3++; }
    c1 = 0;
    c2 = 0;
    for (i = 0; i < height; i++)
    {
        if (i == 0)
        {
            for (int j = 3; j < llb; j++)
            {
                *(source + rst + i*(llb + lgb) + j) = *(v + c1);
                c1++;
            }
            for (int j = llb; j < llb + lgb; j++)
            {
                *(source + rst + i*(llb + lgb) + j) = *(v + c1);
                c1++;
            }
            continue;
        }
        for (int j = 0; j < llb; j++)
            {
                *(source + rst + i*(llb + lgb) + j) = *(v + c1);
                c1++;
            }
        for (int j = llb; j < llb + lgb; j++)
            {
                *(source + rst + i*(llb + lgb) + j) = *(v + c1);
                c1++;
            }
    }
#pragma endregion Writing data
    ofstream outfile("C\\AZ\\ddd.bmp", ios::binary);
    for (i = 0; i < size0; i++)
    {
        outfile << source[i];
    }
    outfile.close();
    return 0;
}
 
unsigned long filesize(const char *FullPath)
{
    struct stat file_stat;
    stat(FullPath, &file_stat);
    return file_stat.st_size;
}
string bin(int DecNumber)
{
    string s;
    int r = DecNumber;
    for (int i = 0; i < 8; i++)
    {
        if (r % 2 == 0) { s = '0' + s; }
        else { s = '1' + s; }
        r = r / 2;
    }
    return s;
}
int dec(string BinNumber)
{
    int n = 0;
    for (int i = 0; i < 8; i++)
    {
        if (BinNumber[i] == '1') { n += pow(2.0, (7 - i)); }
    }
    return n;
}
int getcb(int b_coeff_code)
{
    if (b_coeff_code < 5) { return b_coeff_code; }
    if ((b_coeff_code > 9) && (b_coeff_code < 43))
    {
        b1 = b_coeff_code % 10;
        b2 = b_coeff_code / 10;
        if (cb == 5) { return b1; }
        if (cb == b1) { return b2; }
        else { return b1; }
    }
    if (b_coeff_code > 209)
    {
        b1 = b_coeff_code % 10;
        b2 = b_coeff_code / 10 % 10;
        b3 = b_coeff_code / 100;
        if (cb == 5) { return b1; }
        if (cb == b1) { return b2; }
        if (cb == b2) { return b3; }
        if (cb == b3) { return b1; }
    }
}

unsigned long filesize(const char *FullPath)
{
    struct stat file_stat;
    stat(FullPath, &file_stat);
    return file_stat.st_size;
}

#include <sys/stat.h>

        c3 = n.length() - 1;    //counter 3
    char ext[5];
    do  //getting inf-file extention
    {
        if (c1 < 5)
            ext[c2] = flpath[c3];
        c2--;
        c3--;
        c1++;
    } while (flpath[c3] != '.');