Go. Int64를 벗어나는 스트링 숫자 더하기

package main

import (
    "fmt"
    "log"
    "math"
    "os"
    "strconv"
    "strings"
)

const numberSplit = float64(9)

func main() {
    var argsCount = len(os.Args)
    if argsCount != 3 {
        log.Fatal("please insert args count is 2")
    }

    arg1 := os.Args[1]
    arg2 := os.Args[2]

    result := solution(arg1, arg2)
    fmt.Println(result)

    // Test
    //TestBasic()
}

func TestBasic() {
    result := solution("1123456789", "123456789")
    if result != "1246913578" {
        log.Fatal("Basic testing fail result is", result)
        // or t.Errorf
    }

    fmt.Println(result)
}

func solution(str1 string, str2 string) string {
    number1, err := parseInt(str1)
    if err != nil {
        log.Fatal(err.Error())
    }

    number2, err := parseInt(str2)
    if err != nil {
        log.Fatal(err.Error())
    }

    slice1 := splitInt32(number1)
    slice2 := splitInt32(number2)

    maxLength := int(math.Max(float64(len(slice1)), float64(len(slice2))))

    var tempOver int32 = 0
    var result []int64

    for index := 0; index < maxLength; index++ {
        indexValue1 := arrayIndex(slice1, index)
        indexValue2 := arrayIndex(slice2, index)
        over, sum := sum(indexValue1, indexValue2, tempOver)
        tempOver = over

        result = append(result, sum)
        copy(result[1:], result[0:])
        result[0] = sum
    }

    return strings.Trim(strings.Join(strings.Fields(fmt.Sprint(result)), ""), "[]")
}

func splitInt32(number int64) []int32 {
    var ret []int32
    remain := number
    divide := int64(math.Pow(10, numberSplit))

    for {
        next := remain / divide * divide
        number := remain - next

        ret = append(ret, int32(number))

        remain = remain / divide

        if remain == 0 {
            break
        }
    }

    return ret
}

func arrayIndex(array []int32, index int) int32 {
    if index > len(array) - 1 {
        return 0
    }

    return array[index]
}

func parseInt(arg string) (int64, *customError) {
    number, err := strconv.ParseInt(arg, 10, 64)
    if err != nil {
        return -1, &customError{-1, fmt.Sprintf("%s is not integer.", arg)}
    }

    return number, nil
}

func sum(numbers ...int32) (int32, int64) {
    var sum int64
    for _, number := range numbers {
        sum += int64(number)
    }

    divide := int64(math.Pow(10, numberSplit))
    over := sum / divide
    number := sum - over * divide

    return int32(over), number
}

// - Custom Error

type customError struct {
    code        int
    message     string
}

func (e *customError) Error() string {
    return fmt.Sprintf("%d - %s", e.code, e.message)
}