fileprivate enum Storage : ExpressibleByArrayLiteral {
    typealias Element = Int
    case empty
    case single(Int)
    case pair(Int, Int)
    case array([Int])
    
    init(arrayLiteral elements: Int...) {
        self.init(elements)
    }
    
    init(_ elements: [Int]) {
        switch elements.count {
        case 0:
            self = .empty
            break
        case 1:
            self = .single(elements[0])
            break
        case 2:
            self = .pair(elements[0], elements[1])
            break
        default:
            self = .array(elements)
            break
        }
    }
    
    
    mutating func append(contentsOf other: Storage) {
        switch (self, other) {
        case (_, .empty):
            // DO NOTHING
            break
        case (.empty, _):
            self = other
            break
        case (.single(let first), .single(let second)):
            self = .pair(first, second)
            break
        case (.single(let first), .pair(let second, let third)),
             (.pair(let first, let second), .single(let third)):
            self = .array([first, second, third])
            break
        case (.pair(let first, let second), .pair(let third, let fourth)):
            self = .array([first, second, third, fourth])
            break
        case (.single(let first), .array(let rhsIndexes)):
            self = .array([first] + rhsIndexes)
            break
        case (.pair(let first, let second), .array(let indexes)):
            self = .array([first, second] + indexes)
            break
        case (.array(let indexes), .single(let first)):
            self = .array(indexes + [first])
            break
        case (.array(let indexes), .pair(let first, let second)):
            self = .array(indexes + [first, second])
            break
        case (.array(let lhsIndexes), .array(let rhsIndexes)):
            self = .array(lhsIndexes + rhsIndexes)
            break
        }
        
    }
}