Python integer

(437976919 * 2**(30*0)) + (87719511 * 2**(30*1)) + (107 * 2**(30*2))
a = (437976919 * 2**(30*0))
b = (87719511 * 2**(30*1))
c = (107 * 2**(30*2))

print(a + b + c)

123456789101112131415

	 - long_pow() requires that PyLong_SHIFT be divisible by 5
   - PyLong_{As,From}ByteArray require that PyLong_SHIFT be at least 8
   - long_hash() requires that PyLong_SHIFT is *strictly* less than the number
     of bits in an unsigned long, as do the PyLong <-> long (or unsigned long)
     conversion functions
   - the Python int <-> size_t/Py_ssize_t conversion functions expect that
     PyLong_SHIFT is strictly less than the number of bits in a size_t
   - the marshal code currently expects that PyLong_SHIFT is a multiple of 15
   - NSMALLNEGINTS and NSMALLPOSINTS should be small enough to fit in a single
     digit; with the current values this forces PyLong_SHIFT >= 9

/* 큰 정수 표현법.
   절댓값은 다음과 같이 구할 수 있다.
	   SUM(for i=0 through abs(ob_size)-1) ob_digit[i] * 2**(SHIFT*i)
   ob_size < 0이면 음수를 나타낸다.
   ob_size == 0이면 0을 나타낸다.
   정규화된 수의 경우, ob_digit[abs(ob_size)-1] (최상위 숫자)은 0이 될 수 없다. 또한, 
	 모든 유효한 i 값에 대해 다음이 성립한다. (MASK는 1 << 30 - 1 또는 1 << 15 - 1)
   0 <= ob_digit[i] <= MASK
   할당 함수는 ob_digit[0] ... ob_digit[abs(ob_size)-1]을 실제로 사용할 수 있도록 추가 메모리를 
	 할당을 신경써야 한다.

SHIFT = 30  # number of bits for each 'digit'
MASK = (2 ** SHIFT)
# 2**30 == 1073741824
bignum = 18446744073709551615

def split_number(bignum):
    t = abs(bignum)
    print('split number = {}'.format(t))

    num_list = []
    while t != 0:
        # Get remainder from division
        print('t = {}'.format(t))
        small_int = t % MASK  # more efficient bitwise analogue: (t & (MASK-1))
        print('small_int = {}'.format(small_int))
        num_list.append(small_int)
        print('num_list = {}'.format(num_list))

        # Get integral part of the division (floor division)
        t = t // MASK  # more efficient bitwise analogue: t >>= SHIFT

    return num_list

def restore_number(num_list):
    bignum = 0
    for i, n in enumerate(num_list):
        bignum += n * (2 ** (SHIFT * i))
    return bignum

num_list = split_number(bignum)
assert bignum == restore_number(num_list)

import ctypes

class PyLongObject(ctypes.Structure):
    _fields_ = [("ob_refcnt", ctypes.c_long),
                ("ob_type", ctypes.c_void_p),
                ("ob_size", ctypes.c_ulong),
                ("ob_digit", ctypes.c_uint * 3)]

bignum = 18446744073709551615

# for d in PyLongObject.from_address(id(bignum)).ob_digit:
#     print('')

def add_bignum(a, b):
    z = []

    if len(a) < len(b):
        # Ensure a is the larger of the two
        a, b = b, a

    carry = 0

    for i in range(0, len(b)):
        carry += a[i] + b[i]
        z.append(carry % MASK)
        carry = carry // MASK

    for i in range(i + 1, len(a)):
        carry += a[i]
        z.append(carry % MASK)
        carry = carry // MASK

    z.append(carry)

    # remove trailing zeros
    i = len(z)
    while i > 0 and z[i-1] == 0:
        i -= 1
    z = z[0:i]

    return z

print(2 ** 30)
a = 8223372036854775807
b = 100037203685477
assert restore_number(add_bignum(split_number(a), split_number(b))) == a + b