Ошибка вывода алгоритма сжатия Шенона

Question

Я использую код c алгоритма сжатия Шеннона-Фано.Программа компилируется лучше, но во время выполнения я получаю ошибку ошибки сегментации (дамп ядра).На подобные вопросы уже отвечали, но я попробовал большинство из них, но не смог добиться успеха в устранении этой ошибки.пожалуйста, помогите мне.Код программы:

#include<string.h>
#include<stdlib.h>
#include<stdio.h>
/***********************************************/
int Compress(int* input, int* output, int inputSize);
int main(int argc, char *argv[])
{
    char* str = "This is an example for Shannon–Fano coding";
    printf("%s",str);
    int* originalData = originalData = (int*)str;
    int originalDataSize = strlen(str);

    int* compressedData = (int*)malloc(originalDataSize * (101 / 100) + 384);

    int compressedDataSize = Compress(originalData, compressedData, originalDataSize);
    return 0;
}
typedef struct {
int* BytePointer;
int BitPosition;
} BitStream;

typedef struct {
int Symbol;
int Count;
int Code;
int Bits;
} Symbol;

void initBitStream(BitStream* stream, int* buffer)
{
    stream->BytePointer = buffer;
    stream->BitPosition = 0;
}

void writeBits(BitStream* stream, int x, int bits)
{
    int* buffer = stream->BytePointer;
    int bit = stream->BitPosition;
    int mask = 1 << (bits - 1);

    for (int count = 0; count < bits; ++count)
    {
        *buffer = (*buffer & (0xff ^ (1 << (7 - bit)))) + ((x & mask ? 1 : 0) << (7 - bit));
        x <<= 1;
        bit = (bit + 1) & 7;

        if (!bit)
        {
            ++buffer;
        }
    }

    stream->BytePointer = buffer;
    stream->BitPosition = bit;
}

void histogram(int* input, Symbol* sym, int size)
{
    Symbol temp;
int i, swaps;

for (i = 0; i < 256; ++i)
{
    sym[i].Symbol = i;
    sym[i].Count = 0;
    sym[i].Code = 0;
    sym[i].Bits = 0;
}

for (i = size; i; --i)
{
    sym[*input++].Count++;
}

do
{
    swaps = 0;

    for (i = 0; i < 255; ++i)
    {
        if (sym[i].Count < sym[i + 1].Count)
        {
            temp = sym[i];
            sym[i] = sym[i + 1];
            sym[i + 1] = temp;
            swaps = 1;
        }
    }
} while (swaps);
}

void makeTree(Symbol* sym, BitStream* stream, int code, int bits, int first, int last)
{
int i, size, sizeA, sizeB, lastA, firstB;

if (first == last)
{
    writeBits(stream, 1, 1);
    writeBits(stream, sym[first].Symbol, 8);
    sym[first].Code = code;
    sym[first].Bits = bits;
    return;
}
else
{
    writeBits(stream, 0, 1);
}

size = 0;

for (i = first; i <= last; ++i)
{
    size += sym[i].Count;
}

sizeA = 0;

for (i = first; sizeA < ((size + 1) >> 1) && i < last; ++i)
{
    sizeA += sym[i].Count;
}

if (sizeA > 0)
{
    writeBits(stream, 1, 1);

    lastA = i - 1;

    makeTree(sym, stream, (code << 1) + 0, bits + 1, first, lastA);
}
else
{
    writeBits(stream, 0, 1);
}

sizeB = size - sizeA;

if (sizeB > 0)
{
    writeBits(stream, 1, 1);

    firstB = i;

    makeTree(sym, stream, (code << 1) + 1, bits + 1, firstB, last);
}
else
{
    writeBits(stream, 0, 1);
}
}

int Compress(int* input, int* output, int inputSize)
{
Symbol sym[256], temp;
BitStream stream;
int i, totalBytes, swaps, symbol, lastSymbol;

if (inputSize < 1)
    return 0;

initBitStream(&stream, output);
histogram(input, sym, inputSize);

for (lastSymbol = 255; sym[lastSymbol].Count == 0; --lastSymbol);

if (lastSymbol == 0)
    ++lastSymbol;

makeTree(sym, &stream, 0, 0, 0, lastSymbol);

do
{
    swaps = 0;

    for (i = 0; i < 255; ++i)
    {
        if (sym[i].Symbol > sym[i + 1].Symbol)
        {
            temp = sym[i];
            sym[i] = sym[i + 1];
            sym[i + 1] = temp;
            swaps = 1;
        }
    }
} while (swaps);

for (i = 0; i < inputSize; ++i)
{
    symbol = input[i];
    writeBits(&stream, sym[symbol].Code, sym[symbol].Bits);
}

totalBytes = (int)(stream.BytePointer - output);

if (stream.BitPosition > 0)
{
    ++totalBytes;
}

return totalBytes;
}