AoC-2022 Day 5a -- fast memory arena

#include <stdio.h>

const char* input = R"(    [D]
[N] [C]
[Z] [M] [P]
 1   2   3

move 1 from 2 to 1
move 3 from 1 to 3
move 2 from 2 to 1
move 1 from 1 to 2
)";


struct Node
{
    char payload;
    Node *prev;
    Node *next;
};

#define ARENA_SIZE 1000
Node arena[ARENA_SIZE] = { 0 };
int arenaPointer = ARENA_SIZE - 1;


int main()
{
    int currPile = 0;
    int maxPile = 0;
    int i = 0;
    while (input[i])
    {
        char a = input[i];
        i += (0 != a);
        char b = input[i];
        i += (0 != b);
        char c = input[i];
        i += (0 != c);
        char d = input[i];
        i += (0 != d);

        if ('1' == b)
            break;

        if ('[' == a)
        {
            // find head
            Node* head = &arena[currPile];
            if (nullptr == arena[currPile].next)
            {
                arena[currPile].next = head;
                arena[currPile].prev = head;
            }

            // we will insert right after head
            Node* before = head;
            Node* after = head->next;

            // malloc arena item
            Node* item = &arena[arenaPointer--];
            if(arenaPointer <= 1)
                return -1; // out of memory
            item->payload = b;

            item->prev = before;
            item->next = after;
            before->next = item;
            after->prev = item;
        }

        if (' ' == d)
            currPile++;
        if ('\n' == d)
        {
            maxPile = currPile;
            currPile = 0;
        }
    }

    if(arenaPointer <= maxPile)
        return -1; // out of memory, heads intersected with items


    // Skip two lines
    while (input[i] && ('\n' != input[i]))
    {
        i++;
    }
    while (input[i] && ('\n' == input[i]))
    {
        i++;
    }

    // execute commands
    while (input[i])
    {
        int valCount = 0;
        int valFrom = 0;
        int valTo = 0;


        while (input[i] && ' ' != input[i])
            i++;
        i++;
        while (input[i] && ' ' != input[i])
        {
            valCount = valCount * 10 + input[i] - '0';
            i++;
        }
        i++;

        while (input[i] && ' ' != input[i])
            i++;
        i++;

        while (input[i] && ' ' != input[i])
        {
            valFrom = valFrom * 10 + input[i] - '0';
            i++;
        }
        i++;

        while (input[i] && ' ' != input[i])
            i++;
        i++;

        while (input[i] && '\n' != input[i])
        {
            valTo = valTo * 10 + input[i] - '0';
            i++;
        }
        i++;

        for (int k = 0; k < valCount; k++)
        {
            Node* item = arena[valFrom - 1].prev;
            Node* before = item->prev;
            Node* after = item->next;
            before->next = after;
            after->prev = before;

            Node* newBefore = arena[valTo - 1].prev;
            Node* newAfter = newBefore->next;
            item->prev = newBefore;
            item->next = newAfter;
            newBefore->next = item;
            newAfter->prev = item;
        }
    }

    // print result
    int k = 0;
    while(arena[k].prev)
    {
        Node* last = arena[k].prev;
        if (last->payload)
            putc(last->payload, stdout);
        k++;
    }

    puts("\n");
    return 0;
}