Составить нерекурсивную функцию вычисления N-го числа Фибоначчи - C (СИ) (78276)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <time.h>
 
struct bignum { uint8_t *buffer; size_t  count; };
 
inline static void bignum_create(struct bignum *bn, const char *number)
{
    size_t i, length = strlen(number);
 
    bn->count  = length;
    bn->buffer = (uint8_t*)malloc(length);
 
    for (i=0; i < bn->count; ++i)
        bn->buffer[i] = number[--length] - '0';
}
 
inline static void bignum_destroy(struct bignum *bn)
{
    free(bn->buffer);
    bn->buffer = NULL;
    bn->count  = 0;
}
 
inline static void bignum_expand(struct bignum *bn, size_t new_length)
{
    uint8_t *buffer = (uint8_t*)malloc(new_length);
    memcpy(buffer, bn->buffer, bn->count);
    memset(buffer + bn->count, 0, new_length - bn->count);
 
    bignum_destroy(bn);
    bn->buffer = buffer;
    bn->count  = new_length;
}
 
inline static void bignum_copy(struct bignum *dst, const struct bignum *src)
{
    if (src->count > dst->count)
        bignum_expand(dst, src->count);
 
    memcpy(dst->buffer, src->buffer, src->count);
}
 
inline static void bignum_add(struct bignum *res, const struct bignum *a, const struct bignum *b)
{
    const struct bignum *t;
    size_t i, min_count, max_count;
 
    if (a->count < b->count)
    {
        min_count = a->count;
        max_count = b->count;
        t = b;
    } else
    {
        min_count = b->count;
        max_count = a->count;
        t = a;
    }
 
    if (max_count > res->count)
        bignum_expand(res, max_count);
 
    memset(res->buffer, 0, res->count);
 
    for (i=0; i<max_count; ++i)
    {
        res->buffer[i] += (i < min_count ? a->buffer[i] + b->buffer[i] : t->buffer[i]);
        if (res->buffer[i] > 9)
        {
            if ((i+1) >= max_count)
                bignum_expand(res, max_count + 1);
            res->buffer[i+1] = 1;
            res->buffer[i]  -= 10;
        }
    }
}
 
inline static void bignum_print(struct bignum *bn)
{
    size_t i;
 
    i = bn->count;
 
    while (i--)
        putchar(bn->buffer[i] + '0');
 
    printf("\n");
}
 
inline static void print_fibonacci(uint32_t count)
{
    uint32_t i;
    struct bignum bn[3];
 
    bignum_create(bn,     "1");
    bignum_create(bn + 1, "1");
    bignum_create(bn + 2, "1");
 
    // printf("1\n1\n");
 
    for (i=2; i<count; ++i)
    {
        bignum_add(bn + 2, bn, bn + 1);
        bignum_copy(bn + i%2, bn + 2);
        // bignum_print(bn + 2);
    }
 
    bignum_print(bn + 2);
 
    bignum_destroy(bn);
    bignum_destroy(bn + 1);
    bignum_destroy(bn + 2);
}
 
int main(int ac, char *av[])
{
    clock_t begin, end;
 
    if (ac != 2)
    {
        printf("usage: %s <count>\n", av[0]);
    } else
    {
        begin = clock();
        print_fibonacci(atoi(av[1]));
        end   = clock();
        printf("Tmie = %d ms\n", (end - begin) / (CLOCKS_PER_SEC / 1000));
    }
 
    return 0;
}