Длинная арифметика: возведение в степень - C (СИ)

#ifndef KARATSUBA_H_INCLUDED
#define KARATSUBA_H_INCLUDED
 
#include <basetsd.h>
 
typedef struct _BigInt
{
    UINT32 *digits;
    int length;
} BigInt;
 
BigInt *add(BigInt *, BigInt *);
BigInt *subtract(BigInt *, BigInt *);
BigInt *multiply(BigInt *, BigInt *);
 
#endif // KARATSUBA_H_INCLUDED
 
 
#include <stdlib.h>
#include "karatsuba.h"
 
void normalize(BigInt *);
 
BigInt *add(BigInt *a, BigInt *b)
{
    if (a->length < b->length)
    {
        BigInt *t = a; a = b; b = t;
    }
    BigInt *r = malloc(sizeof(BigInt));
    r->length = a->length + 1;
    r->digits = malloc(r->length * sizeof(UINT32));
    UINT32 carry = 0, i;
    for (i = 0; i < b->length; i++)
    {
        UINT64 d = (UINT64)a->digits[i] + b->digits[i] + carry;
        r->digits[i] = (UINT32)(d & 0xFFFFFFFF);
        carry = (UINT32)(d >> 32);
    }
    for (; i < a->length; i++)
    {
        UINT64 d = (UINT64)a->digits[i] + carry;
        r->digits[i] = (UINT32)(d & 0xFFFFFFFF);
        carry = (UINT32)(d >> 32);
    }
    r->digits[i] = carry;
    normalize(r);
    return r;
}
 
BigInt *multiply(BigInt *a, BigInt *b)
{
    BigInt *r = malloc(sizeof(BigInt));
    // 1. База индукции
    if (a->length == 1 && b->length == 1)
    {
        r->length = 2;
        UINT64 res = a->digits[0] * b->digits[0];
        r->digits = malloc(2 * sizeof(UINT32));
        r->digits[0] = (UINT32)(res & 0xFFFFFFFF);
        r->digits[1] = (UINT32)(res >> 32);
    }
    else
    {
        int length = // первая степень двойки, не меньшая чем a-Length и b->length
        // заполнить нулями недостающие цифры
        BigInt *a0 = malloc(sizeof(BigInt));
        a0->length = length >> 1;
        a0->digits = malloc((length >> 1) * sizeof(UINT32));
        memcpy(a0->digits, a->digits, (length >> 1) * sizeof(UINT32));
 
        BigInt *a1 = // вторая половина a
        BigInt *b0 = // первая половина b
        BigInt *b1 = // вторая половина b
 
        BigInt *z0 = multiply(a0, b0);
        BigInt *z2 = multiply(a1, b1);
        BigInt *z1 = subtract(subtract(multiply(add(a0, a1), add(b0, b1)), z0), z2);
 
        // собрать результат
    }
 
    //
    normalize(r);
    return r;
}
 
void normalize(BigInt *a)
{
    int i = a->length-1;
    while (i > 0 && a->digits[i] == 0) i--;
    a->digits = realloc(a->digits, a->length = i+1);
}