Base 256 array addition Recursively - Follow up This is a follow up code review request from Base 256 array addition Recursively

I have made the changes that were suggested for the RecursiveAdd method. Please take some time to review and help me to make it better.

public class Base256Calculator : IBase256Calculator
{
    private const int Base = 256;

    /// &lt;summary&gt; Adds 2 byte arrays together. &lt;/summary&gt;
    /// &lt;param name="first"&gt;First array.&lt;/param&gt;
    /// &lt;param name="second"&gt;Second array.&lt;/param&gt;
    /// &lt;returns&gt;Result array containing the sum of the two.&lt;/returns&gt;
    public byte[] Add(byte[] first, byte[] second)
    {
        byte[] result = new byte[first.Length];
        return RecursiveAdd(first, second, first.Length - 1, result);
    }

    private byte[] RecursiveAdd(byte[] first, byte[] second, int index, byte[] result, int carry = 0)
    {
        if (index &lt; 0)
        {
            if (carry != 1)
            {
                return result;
            }

            List&lt;byte&gt; resultList = result.ToList();
            resultList.Insert(0, 1);
            return resultList.ToArray();
        }

        int sum = first[index] + second[index] + carry;
        carry = Math.DivRem(sum, Base, out int remainder);
        result[index] = (byte)remainder;
        return RecursiveAdd(first, second, index - 1, result, carry);
    }
}
Limitations

The program has an important limitation:
the two byte arrays must have the same size,
otherwise the result may be incorrect.
If the caller is lucky, the second is shorter than the first,
and the program will crash with an exception.
If the caller is unlucky, the first is shorter,
and the result will be incorrect,
quietly,
without any warning whatsoever.

At the minimum, this limitation should be documented.

Copying an array

When you reach the beginning and there is a carry,
so you need to grow the array to hold the extra value,
converting the array to a list is wasteful.
It would be better to allocate a new array with +1 size,
and use the Array.Copy method to copy the content.

Division is expensive

The use of Math.DivRem may seem clever,
but know that division and remainder computation is usually expensive.
If this operation was natural for your purpose,
that would be fine,
but it's not natural.
What you really need is check that sum &gt;= Base,
and then perform sum -= Base if needed.
It would be better to write the code like that,
simply because that will be more natural to read.