typealias JSON = [String: Any]

enum ParsingError: Error {
    case invalidInput
    case internalError(Error)
}

func parse(string: String) throws -> JSON {
    // Implement me!
}

 {
    // Implement me!
}

typealias JSON = [String: Any]

enum ParsingError: Error {
    case invalidInput
    case internalError(Error)
}

func parse(string: String) throws -> JSON {
    // ...
}

 {
    // ...
}

typealias JSON = [String: Any]

enum ParsingError: Error {
    case invalidInput
    case internalError(Error)
}

func parse(string: String) throws -> JSON {
    // TODO: Implement parsing logic
}

 {
    // TODO: Implement parsing logic
}

typealias JSON = [String: Any]

enum ParsingError: Error {
    case invalidInput
    case internalError(Error)
}

func parse(string: String) throws -> JSON {
    // TODO: implement
}

 {
    // TODO: implement
}

typealias JSON = [String: Any]

enum ParsingError: Error {
    case invalidInput
    case internalError(Error)
}

func parse(string: String) throws -> JSON {
    // TODO: implement me
}

 {
    // TODO: implement me
}

typealias JSON = [String: Any]

enum ParsingError: Error {
    case invalidInput
    case internalError(Error)
}

func parse(string: String) throws -> JSON {
    // TODO: Implement me!
}

 {
    // TODO: Implement me!
}

typealias JSON = [String: Any]

enum ParsingError: Error {
    case invalidInput
    case internalError(Error)
}

func parse(string: String) throws -> JSON {
    // ...
}

 {
    // ...
}

typealias JSON = [String: Any]

enum ParsingError: Error {
    case invalidInput
    case internalError(Error)
}

func parse(string: String) throws -> JSON {
    // ...
}

 {
    // ...
}

typealias JSON = [String: Any]

enum ParsingError: Error {
    case invalidInput
    case internalError(Error)
}

func parse(string: String) throws -> JSON {
    // ...
}

 {
    // ...
}

typealias JSON = [String: Any]

enum ParsingError: Error {
    case invalidInput
    case internalError(Error)
}

func parse(string: String) throws -> JSON {
    // TODO: Implement parsing
}

 {
    // TODO: Implement parsing
}

indirect enum HTMLNode {
    case text(_ content: String)
    case element(_ name: String, attributes: [String : String] = [:], children: [Self] = [])
}

func generate(_ tree: HTMLNode) -> String {
    var result = ""
    for node in tree {
        if let text = node.text {
            result += text
        } else if let element = node.element {
            result += "<" + element.name
            for (key, value) in element.attributes {
                result += " " + key + "=\"" + value + "\""
            }
            result += ">"
            for child in element.children {
                result += generate(child)
            }
            result += "</" + element.name + ">"
        }
    }
    return result
}

 {
    var result = ""
    for node in tree {
        if let text = node.text {
            result += text
        } else if let element = node.element {
            result += "<" + element.name
            for (key, value) in element.attributes {
                result += " " + key + "=\"" + value + "\""
            }
            result += ">"
            for child in element.children {
                result += generate(child)
            }
            result += "</" + element.name + ">"
        }
    }
    return result
}

let tree = [
    element("h1", [String : String]([
        "class" : "title"
    ]), [
        text("HTML")
    ]),
    element("p", [String : String]([
        "class" : "description"
    ]), [
        text("HTML is a markup language for creating web pages."),
        element("a", [String : String]([
            "href" : "https://en.wikipedia.org/wiki/HTML"
        ]), [
            text("More information")
        ])
    ])
])

print(generate(tree))

indirect enum HTMLNode {
    case text(_ content: String)
    case element(_ name: String, attributes: [String : String] = [:], children: [Self] = [])
}

func generate(_ tree: HTMLNode) -> String {
    var result = ""
    let stack = [HTMLNode.element(_ name: "html", attributes: [String : String]([
        "lang" : "en"
    ])), HTMLNode.element(_ name: "head")]
    
    for node in tree {
        switch node {
            case let HTMLNode.element(_ name: "text", content: _ content) {
                result += content
            }
            case let HTMLNode.element(_ name: "element", attributes: _ attributes, children: _ children) {
                let element = HTMLNode.element(_ name: name, attributes: attributes, children: children)
                stack.append(element)
                result += "<" + name
                for (key, value) in attributes {
                    result += " " + key + "=\"" + value + "\""
                }
                result += ">"
                for child in children {
                    result += generate(child)
                }
                result += "</" + name + ">"
                stack.pop()
            }
        }
    }
    return result
}

 {
    var result = ""
    let stack = [HTMLNode.element(_ name: "html", attributes: [String : String]([
        "lang" : "en"
    ])), HTMLNode.element(_ name: "head")]
    
    for node in tree {
        switch node {
            case let HTMLNode.element(_ name: "text", content: _ content) {
                result += content
            }
            case let HTMLNode.element(_ name: "element", attributes: _ attributes, children: _ children) {
                let element = HTMLNode.element(_ name: name, attributes: attributes, children: children)
                stack.append(element)
                result += "<" + name
                for (key, value) in attributes {
                    result += " " + key + "=\"" + value + "\""
                }
                result += ">"
                for child in children {
                    result += generate(child)
                }
                result += "</" + name + ">"
                stack.pop()
            }
        }
    }
    return result
}

let tree = HTMLNode.element(_ name: "div", children: [
    HTMLNode.element(_ name: "a", attributes: [String : String]([
        "href" : "swifteval"
    ])),
    HTMLNode.text(_ content: "Hello world!")
])

print(generate(tree))

indirect enum HTMLNode {
    case text(_ content: String)
    case element(_ name: String, attributes: [String : String] = [:], children: [Self] = [])
}

func generate(_ tree: HTMLNode) -> String {
    let mut result = ""
    let mut stack = [tree]
    while let node = stack.pop() {
        match node {
            case HTMLNode.text(content) in
                result += content
            case HTMLNode.element(name, attributes, children) in
                result += "<$name"
                for (i, attr) in attributes.enumerated() {
                    result += " $attr=\"${attr}\""
                }
                result += ">"
                for child in children {
                    stack.push(child)
                }
                result += "</$name>"
        }
    }
    return result
}

 {
    let mut result = ""
    let mut stack = [tree]
    while let node = stack.pop() {
        match node {
            case HTMLNode.text(content) in
                result += content
            case HTMLNode.element(name, attributes, children) in
                result += "<$name"
                for (i, attr) in attributes.enumerated() {
                    result += " $attr=\"${attr}\""
                }
                result += ">"
                for child in children {
                    stack.push(child)
                }
                result += "</$name>"
        }
    }
    return result
}

indirect enum HTMLNode {
    case text(_ content: String)
    case element(_ name: String, attributes: [String : String] = [:], children: [Self] = [])
}

func generate(_ tree: HTMLNode) -> String {
    // Write code here
}

 {
    // Write code here
}

indirect enum HTMLNode {
    case text(_ content: String)
    case element(_ name: String, attributes: [String : String] = [:], children: [Self] = [])
}

func generate(_ tree: HTMLNode) -> String {
    return tree.generate()
}

extension HTMLNode {
    func generate(_ indent: Int = 0) -> String {
        var result = ""
        for _ in 0..<indent {
            result += "  "
        }
        switch self {
            case let text(content) in
                result += "<text>$content</text>"
            case let element(name, attributes, children) in
                result += "<$name"
                for (key, value) in attributes {
                    result += " $key=\"$value\""
                }
                result += ">"
                for child in children {
                    result += child.generate(indent + 1)
                }
                result += "</$name>"
        }
        return result
    }
}

 {
    return tree.generate()
}

extension HTMLNode {
    func generate(_ indent: Int = 0) -> String {
        var result = ""
        for _ in 0..<indent {
            result += "  "
        }
        switch self {
            case let text(content) in
                result += "<text>$content</text>"
            case let element(name, attributes, children) in
                result += "<$name"
                for (key, value) in attributes {
                    result += " $key=\"$value\""
                }
                result += ">"
                for child in children {
                    result += child.generate(indent + 1)
                }
                result += "</$name>"
        }
        return result
    }
}

let tree = HTMLNode.element("body", [String : String](["class": "main"]) , [
    HTMLNode.element("h1", [String : String](["class": "title"]) , [
        HTMLNode.text("Swift")
    ]),
    HTMLNode.element("h2", [String : String](["class": "subtitle"]) , [
        HTMLNode.text("Programming language")
    ]),
    HTMLNode.element("p", [String : String](["class": "description"]) , [
        HTMLNode.text("Swift is a general-purpose, multi-paradigm, compiled programming language developed by Apple Inc. for iOS and macOS.")
    ]),
    HTMLNode.element("p", [String : String](["class": "description"]) , [
        HTMLNode.text("It is a general-purpose, multi-paradigm, compiled programming language developed by Apple Inc. for iOS and macOS.")
    ]),
    HTMLNode.element("p", [String : String](["class": "description"]) , [
        HTMLNode.text("It is a general-purpose, multi-paradigm, compiled programming language developed by Apple Inc. for iOS and macOS.")
    ]),
    HTMLNode.element("p", [String : String](["class": "description"]) , [
        HTMLNode.text("It is a general-purpose, multi-paradigm, compiled programming language developed by Apple Inc. for iOS and macOS.")
    ]),
    HTMLNode.element("p", [String : String](["class": "description"]) , [
        HTMLNode.text("It is a general-purpose, multi-paradigm, compiled programming language developed by Apple Inc. for iOS and macOS.")
    ]),
    HTMLNode.eleme<|fim_middle|>
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
HTML generator from predefined elements tree.
Output with standart HTML like this "<div><a href="swifteval"></a></div>"
### Response:

indirect enum HTMLNode {
    case text(_ content: String)
    case element(_ name: String, attributes: [String : String] = [:], children: [Self] = [])
}

func generate(_ tree: HTMLNode) -> String {
    // Write your code here
}

 {
    // Write your code here
}

indirect enum HTMLNode {
    case text(_ content: String)
    case element(_ name: String, attributes: [String : String] = [:], children: [Self] = [])
}

func generate(_ tree: HTMLNode) -> String {
    // Write your code here
}

 {
    // Write your code here
}

indirect enum HTMLNode {
    case text(_ content: String)
    case element(_ name: String, attributes: [String : String] = [:], children: [Self] = [])
}

func generate(_ tree: HTMLNode) -> String {
    // TODO: implement me
}

 {
    // TODO: implement me
}

indirect enum HTMLNode {
    case text(_ content: String)
    case element(_ name: String, attributes: [String : String] = [:], children: [Self] = [])
}

func generate(_ tree: HTMLNode) -> String {
    let result = String()
    let stack = [String]()
    let stackAttributes = [[String: String]()]()
    let stackChildren = [[Self]()]()
    let stackAttributesIndex = 0
    let stackChildrenIndex = 0

    for node in tree {
        match node {
            case HTMLNode.text(content) in
                result += content
            case HTMLNode.element(name, attributes, children) in
                let stackAttributesIndex = stackAttributes.count
                let stackChildrenIndex = stackChildren.count
                stack.append(name)
                stackAttributes.append(attributes)
                stackChildren.append(children)
                for child in children {
                    generate(child)
                }
                for _ in 0..<stackAttributesIndex {
                    stackAttributes.pop()
                }
                for _ in 0..<stackChildrenIndex {
                    stackChildren.pop()
                }
        }
    }

    return result
}

 {
    let result = String()
    let stack = [String]()
    let stackAttributes = [[String: String]()]()
    let stackChildren = [[Self]()]()
    let stackAttributesIndex = 0
    let stackChildrenIndex = 0

    for node in tree {
        match node {
            case HTMLNode.text(content) in
                result += content
            case HTMLNode.element(name, attributes, children) in
                let stackAttributesIndex = stackAttributes.count
                let stackChildrenIndex = stackChildren.count
                stack.append(name)
                stackAttributes.append(attributes)
                stackChildren.append(children)
                for child in children {
                    generate(child)
                }
                for _ in 0..<stackAttributesIndex {
                    stackAttributes.pop()
                }
                for _ in 0..<stackChildrenIndex {
                    stackChildren.pop()
                }
        }
    }

    return result
}

indirect enum HTMLNode {
    case text(_ content: String)
    case element(_ name: String, attributes: [String : String] = [:], children: [Self] = [])
}

 {
    var result = ""
    let stack = [String]()
    let attributes = [String : String]()
    let children = [Self]()
    let currentElement = ""
    let currentAttributes = [String : String]()
    let currentChildren = [Self]()
    let currentAttributes = [String : String]()
    let currentChildren = [Self]()

    for node in tree {
        match node {
            case HTMLNode.text(content) in
                result += content
            case HTMLNode.element(name, attributes, children) in
                currentElement = name
                currentAttributes = attributes
                currentChildren = children
                stack.push(currentElement)
                for attribute in currentAttributes {
                    attributes[attribute] = ""
                }
                for child in currentChildren {
                    children.push(child)
                }
            case HTMLNode.element(name, attributes, children) in
                currentElement = name
                currentAttributes = attributes
                currentChildren = children
                stack.push(currentElement)
                for attribute in currentAttributes {
                    attri<|fim_middle|>###<|file_separator|>

enum CalculateError: Error {
    case invalidInput
}

func calculate(_ string: String) throws -> Double {
    let tokens = string.components(separatedBy: " ")
    let result = 0.0
    let stack = ArrayDeque<Double>()
    
    for token in tokens {
        match token {
            case "+" | "-" | "*" | "/" => {
                let b = stack.popLast()!
                let a = stack.popLast()!
                let res = calculate(a, b, token)
                stack.push(res)
            }
            case _ => {
                let num = token.toDouble()
                stack.push(num)
            }
        }
    }
    
    return stack.popLast()!
}

func calculate(_ a: Double, _ b: Double, _ operator: String) throws -> Double {
    switch operator {
        case "+" => return a + b
        case "-" => return a - b
        case "*" => return a * b
        case "/" => return a / b
    }
}

 {
    let tokens = string.components(separatedBy: " ")
    let result = 0.0
    let stack = ArrayDeque<Double>()
    
    for token in tokens {
        match token {
            case "+" | "-" | "*" | "/" => {
                let b = stack.popLast()!
                let a = stack.popLast()!
                let res = calculate(a, b, token)
                stack.push(res)
            }
            case _ => {
                let num = token.toDouble()
                stack.push(num)
            }
        }
    }
    
    return stack.popLast()!
}

func calculate(_ a: Double, _ b: Double, _ operator: String) throws -> Double {
    switch operator {
        case "+" => return a + b
        case "-" => return a - b
        case "*" => return a * b
        case "/" => return a / b
    }
}

enum CalculateError: Error {
    case invalidInput
}

func calculate(_ string: String) throws -> Double {
    let tokens = string.components(separatedBy: " ")
    if tokens.count < 3 {
        throw InvalidInput
    }
    let first = tokens[0]
    let second = tokens[2]
    let operation = tokens[1]
    let firstValue = first.toDouble()
    let secondValue = second.toDouble()
    switch operation {
        case "+":
            return firstValue + secondValue
        case "-":
            return firstValue - secondValue
        case "*":
            return firstValue * secondValue
        case "/":
            return firstValue / secondValue
        default:
            throw InvalidInput
    }
}

func main() {
    let result = calculate("2+2*2")
    print(result)
}

 {
    let tokens = string.components(separatedBy: " ")
    if tokens.count < 3 {
        throw InvalidInput
    }
    let first = tokens[0]
    let second = tokens[2]
    let operation = tokens[1]
    let firstValue = first.toDouble()
    let secondValue = second.toDouble()
    switch operation {
        case "+":
            return firstValue + secondValue
        case "-":
            return firstValue - secondValue
        case "*":
            return firstValue * secondValue
        case "/":
            return firstValue / secondValue
        default:
            throw InvalidInput
    }
}

func main() {
    let result = calculate("2+2*2")
    print(result)
}

enum CalculateError: Error {
    case invalidInput
}

func calculate(_ string: String) throws -> Double {
    let tokens = stringToTokens(string: string)
    let result = calculateTokens(tokens: tokens)
    return result
}

func stringToTokens(_ string: String) -> [Double] {
    var tokens = [Double]()
    var currentToken = ""
    var currentOperator = ""
    for char in string {
        if char.isDigit() {
            currentToken += char
        } else {
            if currentToken.isNotEmpty {
                tokens.append(currentToken.toDouble())
                currentToken = ""
            }
            currentOperator = char
        }
    }
    if currentToken.isNotEmpty {
        tokens.append(currentToken.toDouble())
    }
    return tokens
}

func calculateTokens(_ tokens: [Double]) -> Double {
    var result = tokens[0]
    for i in 1..<tokens.count {
        var operator = ""
        if i < tokens.count {
            operator = tokens[i]
        }
        if operator == "+" {
            result += tokens[i + 1]
        } else if operator == "-" {
            result -= tokens[i + 1]
        } else if operator == "*" {
            result *= tokens[i + 1]
        } else if operator == "/" {
            result /= tokens[i + 1]
        }
    }
    return result
}

func main() {
    let input = "2+2*2"
    let result = calculate(input)
    print(result)
}

 {
    let tokens = stringToTokens(string: string)
    let result = calculateTokens(tokens: tokens)
    return result
}

func stringToTokens(_ string: String) -> [Double] {
    var tokens = [Double]()
    var currentToken = ""
    var currentOperator = ""
    for char in string {
        if char.isDigit() {
            currentToken += char
        } else {
            if currentToken.isNotEmpty {
                tokens.append(currentToken.toDouble())
                currentToken = ""
            }
            currentOperator = char
        }
    }
    if currentToken.isNotEmpty {
        tokens.append(currentToken.toDouble())
    }
    return tokens
}

func calculateTokens(_ tokens: [Double]) -> Double {
    var result = tokens[0]
    for i in 1..<tokens.count {
        var operator = ""
        if i < tokens.count {
            operator = tokens[i]
        }
        if operator == "+" {
            result += tokens[i + 1]
        } else if operator == "-" {
            result -= tokens[i + 1]
        } else if operator == "*" {
            result *= tokens[i + 1]
        } else if operator == "/" {
            result /= tokens[i + 1]
        }
    }
    return result
}

func main() {
    let input = "2+2*2"
    let result = calculate(input)
    print(result)
}

enum CalculateError: Error {
    case invalidInput
}

func calculate(_ string: String) throws -> Double {
    let tokens = stringToTokens(string: string)
    let result = calculateTokens(tokens: tokens)
    return result
}

func calculateTokens(_ tokens: [String]) throws -> Double {
    let result = 0.0
    let stack = [Double]()
    for token in tokens {
        match token {
            case "+" {
                let second = stack.pop()!
                let first = stack.pop()!
                stack.push(first + second)
            }
            case "-" {
                let second = stack.pop()!
                let first = stack.pop()!
                stack.push(first - second)
            }
            case "*" {
                let second = stack.pop()!
                let first = stack.pop()!
                stack.push(first * second)
            }
            case "/" {
                let second = stack.pop()!
                let first = stack.pop()!
                if (second == 0) {
                    throw CalculateError.invalidInput
                }
                stack.push(first / second)
            }
            case _ {
                let number = token.toDouble()
                stack.push(number)
            }
        }
    }
    return stack.pop()!
}

func stringToTokens(_ string: String) -> [String] {
    let tokens = mutableSetOf<String>()
    let number = mutableString()
    for char in string.characters {
        match char {
            case '+' | '-' | '*' | '/' | '(' | ')' {
                if number.isNotEmpty() {
                    tokens.add(number.string)
                    number.clear()
                }
                tokens.add(char.string)
            }
            case '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' {
                number.append(char)
            }
        }
    }
    if number.isNotEmpty() {
        tokens.add(number.string)
    }
    return tokens.sorted()
}

func mutableString() -> String {
    return String()
}

 {
    let tokens = stringToTokens(string: string)
    let result = calculateTokens(tokens: tokens)
    return result
}

func calculateTokens(_ tokens: [String]) throws -> Double {
    let result = 0.0
    let stack = [Double]()
    for token in tokens {
        match token {
            case "+" {
                let second = stack.pop()!
                let first = stack.pop()!
                stack.push(first + second)
            }
            case "-" {
                let second = stack.pop()!
                let first = stack.pop()!
                stack.push(first - second)
            }
            case "*" {
                let second = stack.pop()!
                let first = stack.pop()!
                stack.push(first * second)
            }
            case "/" {
                let second = stack.pop()!
                let first = stack.pop()!
                if (second == 0) {
                    throw CalculateError.invalidInput
                }
                stack.push(first / second)
            }
            case _ {
                let number = token.toDouble()
                stack.push(number)
            }
        }
    }
    return stack.pop()!
}

func stringToTokens(_ string: String) -> [String] {
    let tokens = mutableSetOf<String>()
    let number = mutableString()
    for char in string.characters {
        match char {
            case '+' | '-' | '*' | '/' | '(' | ')' {
                if number.isNotEmpty() {
                    tokens.add(number.string)
                    number.clear()
                }
                tokens.add(char.string)
            }
            case '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' {
                number.append(char)
            }
        }
    }
    if number.isNotEmpty() {
        tokens.add(number.string)
    }
    return tokens.sorted()
}

func mutableString() -> String {
    return String()
}

enum CalculateError: Error {
    case invalidInput
}

func calculate(_ string: String) throws -> Double {
    let tokens = stringToTokens(string: string)
    return calculateTokens(tokens: tokens)
}

func calculateTokens(_ tokens: [String]) throws -> Double {
    let result = 0.0
    let stack = ArrayDeque<Double>()
    let operators = ArrayDeque<String>()
    let current = ""
    for token in tokens {
        if token == "(" {
            operators.push(token)
        } else if token == ")" {
            while operators.last() != "(" {
                let operator = operators.pop()
                let operand2 = stack.pop()
                let operand1 = stack.pop()
                let result = calculateTokens(tokens: [operator, operand1, operand2])
                stack.push(result)
            }
            operators.pop()
        } else if isOperator(token: token) {
            while operators.last() != "(" && hasPrecedence(operator: operators.last(), token: token) {
                let operator = operators.pop()
                let operand2 = stack.pop()
                let operand1 = stack.pop()
                let result = calculateTokens(tokens: [operator, operand1, operand2])
                stack.push(result)
            }
            operators.push(token)
        } else {
            current = token
            if current.isDecimal() {
                current = current.toDouble()
            } else {
                stack.push(current)
            }
        }
    }
    while !operators.isEmpty {
        let operator = operators.pop()
        let operand2 = stack.pop()
        let operand1 = stack.pop()
        let result = calculateTokens(tokens: [operator, operand1, operand2])
        stack.push(result)
    }
    return stack.pop()
}

func isOperator(_ token: String) -> Bool {
    return token == "+" || token == "-" || token == "*" || token == "/"
}

func hasPrecedence(_ operator: String, _ token: String) -> Bool {
    return operator == "*" || operator == "/" || token == "+" || token == "-"
}

func stringToTokens(_ string: String) -> [String] {
    let tokens = []
    let current = ""
    for char in string {
        if char.isDecimal() {
            current = current + char
        } else {
            if current.isNotEmpty() {
                tokens.append(current)
            }
            tokens.append(char)
            current = ""
        }
    }
    if current.isNotEmpty() {
        tokens.append(current)
    }
    return tokens
}

func (String) isDecimal() -> Bool {
    return self.first() == "-" || self.first().isDecimal()
}

func (String) toDouble() -> Double {
    return Double(self)
}

 {
    let tokens = stringToTokens(string: string)
    return calculateTokens(tokens: tokens)
}

func calculateTokens(_ tokens: [String]) throws -> Double {
    let result = 0.0
    let stack = ArrayDeque<Double>()
    let operators = ArrayDeque<String>()
    let current = ""
    for token in tokens {
        if token == "(" {
            operators.push(token)
        } else if token == ")" {
            while operators.last() != "(" {
                let operator = operators.pop()
                let operand2 = stack.pop()
                let operand1 = stack.pop()
                let result = calculateTokens(tokens: [operator, operand1, operand2])
                stack.push(result)
            }
            operators.pop()
        } else if isOperator(token: token) {
            while operators.last() != "(" && hasPrecedence(operator: operators.last(), token: token) {
                let operator = operators.pop()
                let operand2 = stack.pop()
                let operand1 = stack.pop()
                let result = calculateTokens(tokens: [operator, operand1, operand2])
                stack.push(result)
            }
            operators.push(token)
        } else {
            current = token
            if current.isDecimal() {
                current = current.toDouble()
            } else {
                stack.push(current)
            }
        }
    }
    while !operators.isEmpty {
        let operator = operators.pop()
        let operand2 = stack.pop()
        let operand1 = stack.pop()
        let result = calculateTokens(tokens: [operator, operand1, operand2])
        stack.push(result)
    }
    return stack.pop()
}

func isOperator(_ token: String) -> Bool {
    return token == "+" || token == "-" || token == "*" || token == "/"
}

func hasPrecedence(_ operator: String, _ token: String) -> Bool {
    return operator == "*" || operator == "/" || token == "+" || token == "-"
}

func stringToTokens(_ string: String) -> [String] {
    let tokens = []
    let current = ""
    for char in string {
        if char.isDecimal() {
            current = current + char
        } else {
            if current.isNotEmpty() {
                tokens.append(current)
            }
            tokens.append(char)
            current = ""
        }
    }
    if current.isNotEmpty() {
        tokens.append(current)
    }
    return tokens
}

func (String) isDecimal() -> Bool {
    return self.first() == "-" || self.first().isDecimal()
}

func (String) toDouble() -> Double {
    return Double(self)
}

func calculateTokens(tokens: [String]) throws -> Double {
    let result = 0.0
    let stack = ArrayDeque<Double>()
    let operators = ArrayDeque<String>()
    let current = ""
    for token in tokens {
        if token == "(" {
            operators.push(token)
        } else if token == ")" {
            while operators.last() != "(" {
                let operator = operators.pop()
                let operand2 = stack.pop()
                let operand1 = stack.pop()
                let result = calculateTokens(tokens: [operat<|fim_middle|># %%
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Calculator which supports operations from readable string format.
Valid tokens is "+-*/()", example input is "2+2*2".
### Response:

enum CalculateError: Error {
    case invalidInput
}

func calculate(_ string: String) throws -> Double {
    let tokens = string.components(separatedBy: " ")
    if tokens.count != 3 {
        throw InvalidInputError()
    }
    let first = tokens[0]
    let operator = tokens[1]
    let second = tokens[2]
    let firstNumber = first.toDouble()
    let secondNumber = second.toDouble()
    if operator == "+" {
        return firstNumber + secondNumber
    } else if operator == "-" {
        return firstNumber - secondNumber
    } else if operator == "*" {
        return firstNumber * secondNumber
    } else if operator == "/" {
        return firstNumber / secondNumber
    } else {
        throw InvalidInputError()
    }
}

func main() {
    let result = calculate("2+2")
    print(result)
}

 {
    let tokens = string.components(separatedBy: " ")
    if tokens.count != 3 {
        throw InvalidInputError()
    }
    let first = tokens[0]
    let operator = tokens[1]
    let second = tokens[2]
    let firstNumber = first.toDouble()
    let secondNumber = second.toDouble()
    if operator == "+" {
        return firstNumber + secondNumber
    } else if operator == "-" {
        return firstNumber - secondNumber
    } else if operator == "*" {
        return firstNumber * secondNumber
    } else if operator == "/" {
        return firstNumber / secondNumber
    } else {
        throw InvalidInputError()
    }
}

func main() {
    let result = calculate("2+2")
    print(result)
}

enum CalculateError: Error {
    case invalidInput
}

func calculate(_ string: String) throws -> Double {
    let tokens = stringToTokens(string: string)
    let result = calculateTokens(tokens: tokens)
    return result
}

func stringToTokens(_ string: String) -> [Double] {
    let tokens = string.components(separatedBy: " ")
    return tokens.map(string: String) {
        case let number = Int(string: string) {
            number
        }
        case let operator = operator(string: string) {
            operator
        }
    }
}

func calculateTokens(_ tokens: [Double]) -> Double {
    let result = 0.0
    let stack = []<Double>()
    for token in tokens {
        match token {
            case let operator in operator {
                let operand2 = stack.pop()
                let operand1 = stack.pop()
                let operand = operand1 operator operand2
                stack.push(operand)
            }
            case let number in number {
                stack.push(number)
            }
        }
    }
    return stack.pop()
}

func operator(_ string: String) -> (Double? +? Double?) {
    switch string {
        case "+" {
            return { + }
        }
        case "-" {
            return { - }
        }
        case "*" {
            return { * }
        }
        case "/" {
            return { / }
        }
        default {
            return nil
        }
    }
}

 {
    let tokens = stringToTokens(string: string)
    let result = calculateTokens(tokens: tokens)
    return result
}

func stringToTokens(_ string: String) -> [Double] {
    let tokens = string.components(separatedBy: " ")
    return tokens.map(string: String) {
        case let number = Int(string: string) {
            number
        }
        case let operator = operator(string: string) {
            operator
        }
    }
}

func calculateTokens(_ tokens: [Double]) -> Double {
    let result = 0.0
    let stack = []<Double>()
    for token in tokens {
        match token {
            case let operator in operator {
                let operand2 = stack.pop()
                let operand1 = stack.pop()
                let operand = operand1 operator operand2
                stack.push(operand)
            }
            case let number in number {
                stack.push(number)
            }
        }
    }
    return stack.pop()
}

func operator(_ string: String) -> (Double? +? Double?) {
    switch string {
        case "+" {
            return { + }
        }
        case "-" {
            return { - }
        }
        case "*" {
            return { * }
        }
        case "/" {
            return { / }
        }
        default {
            return nil
        }
    }
}

enum CalculateError: Error {
    case invalidInput
}

func calculate(_ string: String) throws -> Double {
    let tokens = stringToTokens(string: string)
    let result = calculateTokens(tokens: tokens)
    return result
}

func calculateTokens(_ tokens: [String]) throws -> Double {
    var result = 0.0
    var operator = ""
    var currentNumber = 0.0
    for token in tokens {
        if let number = token.decimalNumber {
            currentNumber = currentNumber * 10 + number
        } else if token == "+" {
            result += currentNumber
            currentNumber = 0.0
            operator = token
        } else if token == "-" {
            result += currentNumber
            currentNumber = 0.0
            operator = token
        } else if token == "*" {
            result += currentNumber * currentNumber
            currentNumber = 0.0
            operator = token
        } else if token == "/" {
            result += currentNumber / currentNumber
            currentNumber = 0.0
            operator = token
        }
    }
    result += currentNumber
    return result
}

func stringToTokens(_ string: String) throws -> [String] {
    var tokens = [String]()
    var currentToken = ""
    for character in string {
        if character.isDecimalDigit() {
            currentToken += character
        } else if character == "+" || character == "-" || character == "*" || character == "/" {
            tokens.append(currentToken)
            tokens.append(character)
            currentToken = ""
        } else {
            throw InvalidInputError()
        }
    }
    if currentToken.isNotEmpty() {
        tokens.append(currentToken)
    }
    return tokens
}

extension String {
    func decimalNumber() -> Double? {
        return try? Double(rawValue: self)
    }
}

 {
    let tokens = stringToTokens(string: string)
    let result = calculateTokens(tokens: tokens)
    return result
}

func calculateTokens(_ tokens: [String]) throws -> Double {
    var result = 0.0
    var operator = ""
    var currentNumber = 0.0
    for token in tokens {
        if let number = token.decimalNumber {
            currentNumber = currentNumber * 10 + number
        } else if token == "+" {
            result += currentNumber
            currentNumber = 0.0
            operator = token
        } else if token == "-" {
            result += currentNumber
            currentNumber = 0.0
            operator = token
        } else if token == "*" {
            result += currentNumber * currentNumber
            currentNumber = 0.0
            operator = token
        } else if token == "/" {
            result += currentNumber / currentNumber
            currentNumber = 0.0
            operator = token
        }
    }
    result += currentNumber
    return result
}

func stringToTokens(_ string: String) throws -> [String] {
    var tokens = [String]()
    var currentToken = ""
    for character in string {
        if character.isDecimalDigit() {
            currentToken += character
        } else if character == "+" || character == "-" || character == "*" || character == "/" {
            tokens.append(currentToken)
            tokens.append(character)
            currentToken = ""
        } else {
            throw InvalidInputError()
        }
    }
    if currentToken.isNotEmpty() {
        tokens.append(currentToken)
    }
    return tokens
}

extension String {
    func decimalNumber() -> Double? {
        return try? Double(rawValue: self)
    }
}

enum CalculateError: Error {
    case invalidInput
}

func calculate(_ string: String) throws -> Double {
    let tokens = stringToTokens(string: string)
    return calculate(tokens: tokens)
}

func calculate(tokens: [String]) throws -> Double {
    let result = calculate(tokens: tokens, index: 0)
    if index != tokens.count {
        throw InvalidInput()
    }
    return result
}

func calculate(tokens: [String], index: Int) throws -> Double {
    if index >= tokens.count {
        return 0
    }
    let token = tokens[index]
    if token.isOperator() {
        let left = calculate(tokens: tokens, index: index + 1)
        let right = calculate(tokens: tokens, index: index + 2)
        return applyOperator(operator: token, left: left, right: right)
    } else {
        return token.toDouble()
    }
}

func applyOperator(operator: String, left: Double, right: Double) throws -> Double {
    switch operator {
        case "+":
            return left + right
        case "-":
            return left - right
        case "*":
            return left * right
        case "/":
            return left / right
        default:
            throw InvalidInput()
    }
}

func stringToTokens(string: String) -> [String] {
    let result = []
    for token in string.components(separatedBy: " ") {
        if token.isOperator() {
            result.append(token)
        } else {
            result.append(token.trim())
        }
    }
    return result
}

extension String {
    func isOperator() -> Bool {
        return self == "+" || self == "-" || self == "*" || self == "/"
    }
}

extension String {
    func toDouble() throws -> Double {
        return Double(rawValue: self)
    }
}

extension String {
    func components(separatedBy: String) -> [String] {
        var result = []
        var current = ""
        for c in self {
            if c.isWhitespace() {
                if current.isNotEmpty() {
                    result.append(current)
                    current = ""
                }
            } else {
                current += c
            }
        }
        if current.isNotEmpty() {
            result.append(current)
        }
        return result
    }
}

extension String {
    func trim() -> String {
        return self.lstrip().rstrip()
    }
}

extension String {
    func isWhitespace() -> Bool {
        return self == " " || self == "\t" || self == "\n" || self == "\r"
    }
}

 {
    let tokens = stringToTokens(string: string)
    return calculate(tokens: tokens)
}

func calculate(tokens: [String]) throws -> Double {
    let result = calculate(tokens: tokens, index: 0)
    if index != tokens.count {
        throw InvalidInput()
    }
    return result
}

func calculate(tokens: [String], index: Int) throws -> Double {
    if index >= tokens.count {
        return 0
    }
    let token = tokens[index]
    if token.isOperator() {
        let left = calculate(tokens: tokens, index: index + 1)
        let right = calculate(tokens: tokens, index: index + 2)
        return applyOperator(operator: token, left: left, right: right)
    } else {
        return token.toDouble()
    }
}

func applyOperator(operator: String, left: Double, right: Double) throws -> Double {
    switch operator {
        case "+":
            return left + right
        case "-":
            return left - right
        case "*":
            return left * right
        case "/":
            return left / right
        default:
            throw InvalidInput()
    }
}

func stringToTokens(string: String) -> [String] {
    let result = []
    for token in string.components(separatedBy: " ") {
        if token.isOperator() {
            result.append(token)
        } else {
            result.append(token.trim())
        }
    }
    return result
}

extension String {
    func isOperator() -> Bool {
        return self == "+" || self == "-" || self == "*" || self == "/"
    }
}

extension String {
    func toDouble() throws -> Double {
        return Double(rawValue: self)
    }
}

extension String {
    func components(separatedBy: String) -> [String] {
        var result = []
        var current = ""
        for c in self {
            if c.isWhitespace() {
                if current.isNotEmpty() {
                    result.append(current)
                    current = ""
                }
            } else {
                current += c
            }
        }
        if current.isNotEmpty() {
            result.append(current)
        }
        return result
    }
}

extension String {
    func trim() -> String {
        return self.lstrip().rstrip()
    }
}

extension String {
    func isWhitespace() -> Bool {
        return self == " " || self == "\t" || self == "\n" || self == "\r"
    }
}

extension String {
    func isOperator() -> Bool {
        return self == "+" || self == "-" || self == "*" || self == "/"
    }
}

extension String {
    func toDouble() throws -> Double {
        return Double(rawValue: self)
    }
}

extension String {
    func components(separatedBy: String) -> [String] {
        var result = []
        var current = ""
        for c in self {
            if c.isWhitespace() {
                if current.isNotEmpty() {
                    result.append(current)
                    current = ""
                }
            } else {
                current += c
            }
        }
        if current.isNotEmpty() {
            result.append(current)
        }
        return result
    }
}

extension String {
    func trim() -> String {
        return self.lstrip().rstrip()
    }
}

extension String {
    func isWhitespace() -> Bool {
        return self == " " || self == "\t" || self == "\n" || self == "\r"
    }
}

extension String {
    func isOperator() -> Bool {
        return self == "+" || self == "-" || self == "*" || self == "/"
    }
}

extension String {
    func toDouble() throws -> Double {
        return Double(rawValue: self)
    }
}

extension String {
    func components(separatedBy: String) -> [String] {
        var result = []
        var current = ""
        for c in self {
            if c.isWhitespace() {
                if current.isNotEmpty() {
                    result.append(current)
                    curren<|fim_middle|># %%
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Calculator which supports operations

enum CalculateError: Error {
    case invalidInput
}

func calculate(_ string: String) throws -> Double {
    let tokens = stringToTokens(string: string)
    return calculate(tokens: tokens)
}

func calculate(tokens: [String]) throws -> Double {
    let result = 0.0
    let operator = ""
    for token in tokens {
        if let number = token.decimalNumber() {
            if operator == "" {
                result = number
            } else {
                result = calculate(result: result, operator: operator, number: number)
            }
        } else if let operator = token {
            if operator == "+" {
                result += number
            } else if operator == "-" {
                result -= number
            } else if operator == "*" {
                result *= number
            } else if operator == "/" {
                result /= number
            }
        } else {
            throw InvalidArgumentException(message: "Invalid input")
        }
    }
    return result
}

func stringToTokens(string: String) -> [String] {
    let tokens = []
    let currentToken = ""
    for character in string {
        if character.isDecimalDigit() {
            currentToken += character
        } else if currentToken.isNotEmpty() {
            tokens.append(currentToken)
            currentToken = ""
        }
        if character.isOneOf("+-*/()") {
            tokens.append(character.string())
        }
    }
    if currentToken.isNotEmpty() {
        tokens.append(currentToken)
    }
    return tokens
}

func calculate(result: Double, operator: String, number: Double) -> Double {
    if operator == "+" {
        return result + number
    } else if operator == "-" {
        return result - number
    } else if operator == "*" {
        return result * number
    } else if operator == "/" {
        return result / number
    } else {
        throw InvalidArgumentException(message: "Invalid input")
    }
}

func (token String) decimalNumber() -> Double? {
    let number = try token.decimalNumber()
    return number
}

func (token String) isDecimalDigit() -> Bool {
    let number = try token.decimalNumber()
    return number != nil
}

func (token String) isOneOf(characters: String) -> Bool {
    for character in characters {
        if token == character {
            return true
        }
    }
    return false
}

func (token String) string() -> String {
    return token
}

 {
    let tokens = stringToTokens(string: string)
    return calculate(tokens: tokens)
}

func calculate(tokens: [String]) throws -> Double {
    let result = 0.0
    let operator = ""
    for token in tokens {
        if let number = token.decimalNumber() {
            if operator == "" {
                result = number
            } else {
                result = calculate(result: result, operator: operator, number: number)
            }
        } else if let operator = token {
            if operator == "+" {
                result += number
            } else if operator == "-" {
                result -= number
            } else if operator == "*" {
                result *= number
            } else if operator == "/" {
                result /= number
            }
        } else {
            throw InvalidArgumentException(message: "Invalid input")
        }
    }
    return result
}

func stringToTokens(string: String) -> [String] {
    let tokens = []
    let currentToken = ""
    for character in string {
        if character.isDecimalDigit() {
            currentToken += character
        } else if currentToken.isNotEmpty() {
            tokens.append(currentToken)
            currentToken = ""
        }
        if character.isOneOf("+-*/()") {
            tokens.append(character.string())
        }
    }
    if currentToken.isNotEmpty() {
        tokens.append(currentToken)
    }
    return tokens
}

func calculate(result: Double, operator: String, number: Double) -> Double {
    if operator == "+" {
        return result + number
    } else if operator == "-" {
        return result - number
    } else if operator == "*" {
        return result * number
    } else if operator == "/" {
        return result / number
    } else {
        throw InvalidArgumentException(message: "Invalid input")
    }
}

func (token String) decimalNumber() -> Double? {
    let number = try token.decimalNumber()
    return number
}

func (token String) isDecimalDigit() -> Bool {
    let number = try token.decimalNumber()
    return number != nil
}

func (token String) isOneOf(characters: String) -> Bool {
    for character in characters {
        if token == character {
            return true
        }
    }
    return false
}

func (token String) string() -> String {
    return token
}

func (token String) decimalNumber() -> Double? {
    let number = try token.decimalNumber()
    return number
}

func (token String) isDecimalDigit() -> Bool {
    let number = try token.decimalNumber()
    return number != nil
}

func (token String) isOneOf(characters: String) -> Bool {
    for character in characters {
        if token == character {
            return true
        }
    }
    return false
}

func (token String) string() -> String {
    return token
}

func (token String) decimalNumber() -> Double? {
    let number = try token.decimalNumber()
    return number
}

func (token String) isDecimalDigit() -> Bool {
    let number = try token.decimalNumber()
    return number != nil
}

func (token String) isOneOf(characters: String) -> Bool {
    for character in characters {
        if token == character {
            return true
        }
    }
    return false
}

func (token String) string() -> String {
    return token
}

func (token String) decimalNumber() -> Double? {
    let number = try token.decimalNumber()
    return number
}

func (token String) isDecimalDigit() -> Bool {
    let number = try token.decimalNumber()
    return number != nil
}

func (token String) isOneOf(characters: String) -> Bool {
    for character in characters {
        if token == character {
            return true
        }
    }
    return false
}

func (token String) string() -> String {
    return token
}

func (token String) decimalNumber() -> Double? {
    let number = try token.decimalNumber()
    return number
}

func (token String) isDecimalDigit() -> Bool {
    let number = try token.decimalNumber()
    return number != nil
}

func (token String) isOneOf(characters: String) ->

func execute(binary: String, arguments: [String]) -> (String, String) {
    let command = Command(executablePath: binary, arguments: arguments)
    let output = command.run()
    return (output.standardOutput, output.standardError)
}

 {
    let command = Command(executablePath: binary, arguments: arguments)
    let output = command.run()
    return (output.standardOutput, output.standardError)
}

func execute(binary: String, arguments: [String]) -> (String, String) {
    let (stdout, stderr) = (String(), String())
    let process = Process(argv: [binary, arguments])
    process.launch()
    process.standardOutput?.read(to: &stdout)
    process.standardError?.read(to: &stderr)
    return (stdout, stderr)
}

 {
    let (stdout, stderr) = (String(), String())
    let process = Process(argv: [binary, arguments])
    process.launch()
    process.standardOutput?.read(to: &stdout)
    process.standardError?.read(to: &stderr)
    return (stdout, stderr)
}

func execute(binary: String, arguments: [String]) -> (String, String) {
  let (stdout, stderr) = (String(), String())
  let process = Process(argv: [binary, arguments])
  process.standardOutput = stdout
  process.standardError = stderr
  process.launch()
  return (stdout, stderr)
}

 {
  let (stdout, stderr) = (String(), String())
  let process = Process(argv: [binary, arguments])
  process.standardOutput = stdout
  process.standardError = stderr
  process.launch()
  return (stdout, stderr)
}

func execute(binary: String, arguments: [String]) -> (String, String) {
    let process = Process(argv: [binary, arguments])
    process.launch()
    let stdout = process.standardOutput.read() ?? ""
    let stderr = process.standardError.read() ?? ""
    return (stdout, stderr)
}

 {
    let process = Process(argv: [binary, arguments])
    process.launch()
    let stdout = process.standardOutput.read() ?? ""
    let stderr = process.standardError.read() ?? ""
    return (stdout, stderr)
}

func execute(binary: String, arguments: [String]) -> (String, String) {
    let command = Command(workingDirectory: "bin", executablePath: binary, arguments: arguments)
    let result = command.run()
    let stdout = result.stdout
    let stderr = result.stderr
    return (stdout, stderr)
}

 {
    let command = Command(workingDirectory: "bin", executablePath: binary, arguments: arguments)
    let result = command.run()
    let stdout = result.stdout
    let stderr = result.stderr
    return (stdout, stderr)
}

func execute(binary: String, arguments: [String]) -> (String, String) {
    let (stdout, stderr) = (String(), String())
    let process = Process(argv: [binary, arguments])
    process.launch()
    process.standardOutput?.read(into: &stdout)
    process.standardError?.read(into: &stderr)
    return (stdout, stderr)
}

 {
    let (stdout, stderr) = (String(), String())
    let process = Process(argv: [binary, arguments])
    process.launch()
    process.standardOutput?.read(into: &stdout)
    process.standardError?.read(into: &stderr)
    return (stdout, stderr)
}

func execute(binary: String, arguments: [String]) -> (String, String) {
  let command = Process(argv: [binary, arguments])
  let stdout = command.standardOutput.read()
  let stderr = command.standardError.read()
  return (stdout, stderr)
}

 {
  let command = Process(argv: [binary, arguments])
  let stdout = command.standardOutput.read()
  let stderr = command.standardError.read()
  return (stdout, stderr)
}

func execute(binary: String, arguments: [String]) -> (String, String) {
    let command = binary
    let args = arguments
    let process = Process(command: command, arguments: args, error: &error)
    let stdout = String(from: process.output)
    let stderr = String(from: process.error)
    return (stdout, stderr)
}

 {
    let command = binary
    let args = arguments
    let process = Process(command: command, arguments: args, error: &error)
    let stdout = String(from: process.output)
    let stderr = String(from: process.error)
    return (stdout, stderr)
}

func execute(binary: String, arguments: [String]) -> (String, String) {
  let command = "/bin/bash"
  let arguments = ["-c", binary, arguments.joined(" ")]
  let process = Process(executablePath: command, arguments: arguments)
  let stdout = process.standardOutput.read()
  let stderr = process.standardError.read()
  return (stdout, stderr)
}

 {
  let command = "/bin/bash"
  let arguments = ["-c", binary, arguments.joined(" ")]
  let process = Process(executablePath: command, arguments: arguments)
  let stdout = process.standardOutput.read()
  let stderr = process.standardError.read()
  return (stdout, stderr)
}

func execute(binary: String, arguments: [String]) -> (String, String) {
    let process = Process(argv: [binary, arguments])
    process.launch()
    let stdout = process.standardOutputString()
    let stderr = process.standardErrorString()
    process.terminate()
    return (stdout, stderr)
}

 {
    let process = Process(argv: [binary, arguments])
    process.launch()
    let stdout = process.standardOutputString()
    let stderr = process.standardErrorString()
    process.terminate()
    return (stdout, stderr)
}

func memoize<T: Hashable, U>(_ function: @escaping (T) -> U) -> (T) -> U {
  var cache = Map<T, U>()
  return { key in
    if let value = cache[key] {
      value
    } else {
      let result = function(key)
      cache[key] = result
      result
    }
  }
}

 {
  var cache = Map<T, U>()
  return { key in
    if let value = cache[key] {
      value
    } else {
      let result = function(key)
      cache[key] = result
      result
    }
  }
}

func memoize<T: Hashable, U>(_ function: @escaping (T) -> U) -> (T) -> U {
  var cache = Map<T, U>()
  return { input in
    if cache.has(input) {
      cache[input]
    } else {
      let result = function(input)
      cache[input] = result
      result
    }
  }
}

 {
  var cache = Map<T, U>()
  return { input in
    if cache.has(input) {
      cache[input]
    } else {
      let result = function(input)
      cache[input] = result
      result
    }
  }
}

func memoize<T: Hashable, U>(_ function: @escaping (T) -> U) -> (T) -> U {
  var cache = Map<T, U>()
  return { input in
    let result = cache[input]
    if result == nil {
      result = function(input)
      cache[input] = result
    }
    result
  }
}

 {
  var cache = Map<T, U>()
  return { input in
    let result = cache[input]
    if result == nil {
      result = function(input)
      cache[input] = result
    }
    result
  }
}

func memoize<T: Hashable, U>(_ function: @escaping (T) -> U) -> (T) -> U {
  var cache = Map<T, U>()
  return { key in
    if let value = cache[key] {
      value
    } else {
      let value = function(key)
      cache[key] = value
      value
    }
  }
}

func expensiveComputation(key: Int) -> Int {
  // Simulate an expensive computation
  return key * key
}

 {
  var cache = Map<T, U>()
  return { key in
    if let value = cache[key] {
      value
    } else {
      let value = function(key)
      cache[key] = value
      value
    }
  }
}

func expensiveComputation(key: Int) -> Int {
  // Simulate an expensive computation
  return key * key
}

let memoizedExpensiveComputation = memoize(expensiveComputation)

let result1 = memoizedExpensiveComputation(1)
let result2 = memoizedExpensiveComputation(2)

print(result1) // Prints 1
print(result2) // Prints 4
print(result1) // Prints 1 (from cache)
print(result2) // Prints 4 (from cache)

func memoize<T: Hashable, U>(_ function: @escaping (T) -> U) -> (T) -> U {
  var cache = Map<T, U>()
  return { key in
    if let cachedValue = cache[key] {
      cachedValue
    } else {
      let value = function(key)
      cache[key] = value
      value
    }
  }
}

func factorial(n: Int) -> Int {
  if n == 0 {
    return 1
  }
  return n * factorial(n - 1)
}

 {
  var cache = Map<T, U>()
  return { key in
    if let cachedValue = cache[key] {
      cachedValue
    } else {
      let value = function(key)
      cache[key] = value
      value
    }
  }
}

func factorial(n: Int) -> Int {
  if n == 0 {
    return 1
  }
  return n * factorial(n - 1)
}

let memoizedFactorial = memoize(factorial)
let result = memoizedFactorial(5)
print(result) // Output: 120

func memoize<T: Hashable, U>(_ function: @escaping (T) -> U) -> (T) -> U {
  var cache = Map<T, U>()
  return { key in
    if let cachedValue = cache[key] {
      cachedValue
    } else {
      let value = function(key)
      cache[key] = value
      value
    }
  }
}

 {
  var cache = Map<T, U>()
  return { key in
    if let cachedValue = cache[key] {
      cachedValue
    } else {
      let value = function(key)
      cache[key] = value
      value
    }
  }
}

func memoize<T: Hashable, U>(_ function: @escaping (T) -> U) -> (T) -> U {
  var cache = Map<T, U>()
  return { key in
    let result = cache[key]
    if result == nil {
      result = function(key)
      cache[key] = result
    }
    result
  }
}

 {
  var cache = Map<T, U>()
  return { key in
    let result = cache[key]
    if result == nil {
      result = function(key)
      cache[key] = result
    }
    result
  }
}

func memoize<T: Hashable, U>(_ function: @escaping (T) -> U) -> (T) -> U {
  var cache = Map<T, U>()
  return { input in
    let cachedValue = cache[input]
    if cachedValue != nil {
      cachedValue
    } else {
      let result = function(input)
      cache[input] = result
      result
    }
  }
}

 {
  var cache = Map<T, U>()
  return { input in
    let cachedValue = cache[input]
    if cachedValue != nil {
      cachedValue
    } else {
      let result = function(input)
      cache[input] = result
      result
    }
  }
}

func memoize<T: Hashable, U>(_ function: @escaping (T) -> U) -> (T) -> U {
  var cache = Map<T, U>()
  return { key in
    if let cachedValue = cache[key] {
      cachedValue
    } else {
      let value = function(key)
      cache[key] = value
      value
    }
  }
}

 {
  var cache = Map<T, U>()
  return { key in
    if let cachedValue = cache[key] {
      cachedValue
    } else {
      let value = function(key)
      cache[key] = value
      value
    }
  }
}

let memoizedFunction = memoize(function: { key in
  print("Calculating value for key: \(key)")
  key.uppercase()
})

let result1 = memoizedFunction("hello")
let result2 = memoizedFunction("world")
let result3 = memoizedFunction("hello")

print("Result 1: \(result1)")
print("Result 2: \(result2)")
print("Result 3: \(result3)")

func memoize<T: Hashable, U>(_ function: @escaping (T) -> U) -> (T) -> U {
  var cache = Map<T, U>()
  return { key in
    if let cachedValue = cache[key] {
      cachedValue
    } else {
      let value = function(key)
      cache[key] = value
      value
    }
  }
}

 {
  var cache = Map<T, U>()
  return { key in
    if let cachedValue = cache[key] {
      cachedValue
    } else {
      let value = function(key)
      cache[key] = value
      value
    }
  }
}

func retry<T>(attempts: Int, task: @escaping () throws -> T) throws -> T {
  var result: T? = nil
  var error: Error? = nil
  for i in 1...attempts {
    try {
      result = task()
      break
    } catch let e {
      error = e
    }
  }
  if let error = error {
    throw error!
  } else {
    return result!
  }
}

 {
  var result: T? = nil
  var error: Error? = nil
  for i in 1...attempts {
    try {
      result = task()
      break
    } catch let e {
      error = e
    }
  }
  if let error = error {
    throw error!
  } else {
    return result!
  }
}

func retry<T>(attempts: Int, task: @escaping () throws -> T) throws -> T {
  var error: Error? = nil
  for i in 0..<attempts {
    try {
      return task()
    } catch (e) {
      error = e
    }
  }
  throw error!
}

 {
  var error: Error? = nil
  for i in 0..<attempts {
    try {
      return task()
    } catch (e) {
      error = e
    }
  }
  throw error!
}

func retry<T>(attempts: Int, task: @escaping () throws -> T) throws -> T {
  var error: Error? = nil
  for i in 0..<attempts {
    try {
      return task()
    } catch (e) {
      error = e
    }
  }
  throw error!
}

 {
  var error: Error? = nil
  for i in 0..<attempts {
    try {
      return task()
    } catch (e) {
      error = e
    }
  }
  throw error!
}

func retry<T>(attempts: Int, task: @escaping () throws -> T) throws -> T {
    var error: Error? = nil
    for i in 0..<attempts {
        try {
            return task()
        } catch (err) {
            error = err
            if i == attempts - 1 {
                throw error
            }
        }
    }
}

func main() {
    let attempts = 3
    let result = retry(attempts: attempts) {
        if true {
            throw Error("Something went wrong")
        }
        "Success"
    }
    print(result) // prints "Success"
}

 {
    var error: Error? = nil
    for i in 0..<attempts {
        try {
            return task()
        } catch (err) {
            error = err
            if i == attempts - 1 {
                throw error
            }
        }
    }
}

func main() {
    let attempts = 3
    let result = retry(attempts: attempts) {
        if true {
            throw Error("Something went wrong")
        }
        "Success"
    }
    print(result) // prints "Success"
}

func retry<T>(attempts: Int, task: @escaping () throws -> T) throws -> T {
  var result: T? = nil
  var attemptsRemaining = attempts
  while attemptsRemaining > 0 && result == nil {
    try {
      result = task()
    } catch {
      attemptsRemaining -= 1
      if attemptsRemaining == 0 {
        throw
      }
    }
  }
  return result!
}

func main() {
  let result = retry(3) {
    if true {
      throw "Error"
    } else {
      return "Success"
    }
  }
  print(result) // Prints "Success"
}

 {
  var result: T? = nil
  var attemptsRemaining = attempts
  while attemptsRemaining > 0 && result == nil {
    try {
      result = task()
    } catch {
      attemptsRemaining -= 1
      if attemptsRemaining == 0 {
        throw
      }
    }
  }
  return result!
}

func main() {
  let result = retry(3) {
    if true {
      throw "Error"
    } else {
      return "Success"
    }
  }
  print(result) // Prints "Success"
}

func retry<T>(attempts: Int, task: @escaping () throws -> T) throws -> T {
  var result: T? = nil
  var attemptsLeft = attempts
  while attemptsLeft > 0 {
    try {
      result = task()
      break
    } catch {
      attemptsLeft -= 1
      if attemptsLeft == 0 {
        throw
      }
    }
  }
  return result!
}

 {
  var result: T? = nil
  var attemptsLeft = attempts
  while attemptsLeft > 0 {
    try {
      result = task()
      break
    } catch {
      attemptsLeft -= 1
      if attemptsLeft == 0 {
        throw
      }
    }
  }
  return result!
}

func retry<T>(attempts: Int, task: @escaping () throws -> T) throws -> T {
    var result: T? = nil
    var error: Error? = nil
    for i in 0..<attempts {
        try {
            result = task()
            break
        } catch let e {
            error = e
        }
    }
    if let error = error {
        throw error
    }
    return result!
}

func main() {
    let attempts = 3
    let result = retry(attempts) {
        throw Error("Failed to connect")
    }
    print(result)
}

 {
    var result: T? = nil
    var error: Error? = nil
    for i in 0..<attempts {
        try {
            result = task()
            break
        } catch let e {
            error = e
        }
    }
    if let error = error {
        throw error
    }
    return result!
}

func main() {
    let attempts = 3
    let result = retry(attempts) {
        throw Error("Failed to connect")
    }
    print(result)
}

func retry<T>(attempts: Int, task: @escaping () throws -> T) throws -> T {
  var result: T? = nil
  var error: Error? = nil
  for i in 0..<attempts {
    result = try task()
    if result != nil {
      return result
    }
    error = catch {
      if let error = catch {
        error
      }
    }
    sleep(Duration(seconds: 1))
  }
  throw error!("Failed after $attempts attempts")
}

 {
  var result: T? = nil
  var error: Error? = nil
  for i in 0..<attempts {
    result = try task()
    if result != nil {
      return result
    }
    error = catch {
      if let error = catch {
        error
      }
    }
    sleep(Duration(seconds: 1))
  }
  throw error!("Failed after $attempts attempts")
}

func retry<T>(attempts: Int, task: @escaping () throws -> T) throws -> T {
    var error: Error? = nil
    for attempt in 1...attempts {
        try {
            return task()
        } catch (e) {
            error = e
        }
    }
    throw error!
}

 {
    var error: Error? = nil
    for attempt in 1...attempts {
        try {
            return task()
        } catch (e) {
            error = e
        }
    }
    throw error!
}

func retry<T>(attempts: Int, task: @escaping () throws -> T) throws -> T {
  var result: T? = nil
  var error: Error? = nil
  for i in 0..<attempts {
    try {
      result = task()
      break
    } catch let e {
      error = e
    }
  }
  if let error = error {
    throw error
  }
  return result!
}

 {
  var result: T? = nil
  var error: Error? = nil
  for i in 0..<attempts {
    try {
      result = task()
      break
    } catch let e {
      error = e
    }
  }
  if let error = error {
    throw error
  }
  return result!
}

protocol DIContainerProtocol {
    func register<T>(_ type: T.Type, factory: @escaping () -> T)
    func resolve<T>(_ type: T.Type) -> T?
}

class DIContainer: DIContainerProtocol {
    var _registry: [Type: @escaping () -> Any] = {}
    
    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        _registry[type] = factory
    }
    
    func resolve<T>(_ type: T.Type) -> T? {
        return _registry[type]() as? T
    }
}

protocol MyProtocol {
    func doSomething() -> String
}

class MyImplementation: MyProtocol {
    func doSomething() -> String {
        return "Hello, World!"
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

 DIContainerProtocol {
    var _registry: [Type: @escaping () -> Any] = {}
    
    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        _registry[type] = factory
    }
    
    func resolve<T>(_ type: T.Type) -> T? {
        return _registry[type]() as? T
    }
}

protocol MyProtocol {
    func doSomething() -> String
}

class MyImplementation: MyProtocol {
    func doSomething() -> String {
        return "Hello, World!"
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<T>() as? T
    }
}

extension DIContainer {
    func resolve<T>(_ type: T.Type) -> T? {
        return super.resolve<

protocol DIContainerProtocol {
    func register<T>(_ type: T.Type, factory: @escaping () -> T)
    func resolve<T>(_ type: T.Type) -> T?
}

class DIContainer: DIContainerProtocol {
    private var _registry: [Type: Any] = {}
    
    public func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        self._registry[type] = factory
    }
    
    public func resolve<T>(_ type: T.Type) -> T? {
        guard let factory = self._registry[type] else {
            return nil
        }
        return factory() as T?
    }
}

class Foo {
    var bar: Bar
    var baz: Baz
    
    init() {
        self.bar = Bar()
        self.baz = Baz()
    }
}

class Bar {
    var foo: Foo
    
    init() {
        self.foo = Foo()
    }
}

class Baz {
    var foo: Foo
    
    init() {
        self.foo = Foo()
    }
}

 DIContainerProtocol {
    private var _registry: [Type: Any] = {}
    
    public func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        self._registry[type] = factory
    }
    
    public func resolve<T>(_ type: T.Type) -> T? {
        guard let factory = self._registry[type] else {
            return nil
        }
        return factory() as T?
    }
}

class Foo {
    var bar: Bar
    var baz: Baz
    
    init() {
        self.bar = Bar()
        self.baz = Baz()
    }
}

class Bar {
    var foo: Foo
    
    init() {
        self.foo = Foo()
    }
}

class Baz {
    var foo: Foo
    
    init() {
        self.foo = Foo()
    }
}

let container = DIContainer()
container.register<Foo>(type: Foo.Type, factory: {Foo()})
container.register<Bar>(type: Bar.Type, factory: {Bar()})
container.register<Baz>(type: Baz.Type, factory: {Baz()})

let foo = container.resolve<Foo>()
let bar = container.resolve<Bar>()
let baz = container.resolve<Baz>()

protocol DIContainerProtocol {
    func register<T>(_ type: T.Type, factory: @escaping () -> T)
    func resolve<T>(_ type: T.Type) -> T?
}

class DIContainer: DIContainerProtocol {
    private var _container: MutableDictionary<Type, Any?> = [:]
    public init() {
        register<DIContainerProtocol>(factory: { self })
    }

    public func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        _container[type] = factory()
    }

    public func resolve<T>(_ type: T.Type) -> T? {
        return _container[type] as? T
    }
}

protocol SomeProtocol {
    var someProperty: String
}

class SomeImplementation: SomeProtocol {
    public var someProperty: String = "Some value"
}

class SomeClass {
    public var someProtocol: SomeProtocol
    public init() {
        let diContainer = DIContainer()
        diContainer.register<SomeProtocol>(factory: { SomeImplementation() })
        someProtocol = diContainer.resolve<SomeProtocol>()!
    }
}

 DIContainerProtocol {
    private var _container: MutableDictionary<Type, Any?> = [:]
    public init() {
        register<DIContainerProtocol>(factory: { self })
    }

    public func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        _container[type] = factory()
    }

    public func resolve<T>(_ type: T.Type) -> T? {
        return _container[type] as? T
    }
}

protocol SomeProtocol {
    var someProperty: String
}

class SomeImplementation: SomeProtocol {
    public var someProperty: String = "Some value"
}

class SomeClass {
    public var someProtocol: SomeProtocol
    public init() {
        let diContainer = DIContainer()
        diContainer.register<SomeProtocol>(factory: { SomeImplementation() })
        someProtocol = diContainer.resolve<SomeProtocol>()!
    }
}

let someClass = SomeClass()
print(someClass.someProtocol.someProperty)

protocol DIContainerProtocol {
    func register<T>(_ type: T.Type, factory: @escaping () -> T)
    func resolve<T>(_ type: T.Type) -> T?
}

class DIContainer: DIContainerProtocol {
    private var _registry: [Type: Any] = {}

    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        self._registry[type] = factory
    }

    func resolve<T>(_ type: T.Type) -> T? {
        guard let factory = self._registry[type] else {
            return nil
        }
        return factory() as T
    }
}

protocol SomeProtocol {
    var someProperty: String
}

class SomeImplementation: SomeProtocol {
    override var someProperty = "Some value"
}

class SomeService {
    var someProtocol: SomeProtocol
    var someProperty: String
    var someImplementation: SomeImplementation
    var diContainer: DIContainerProtocol
}

extension SomeService {
    init() {
        diContainer = DIContainer()
        diContainer.register<SomeProtocol>(SomeProtocol) { self }
        diContainer.register<SomeImplementation>(SomeImplementation) { self }
        someProtocol = diContainer.resolve<SomeProtocol>()!
        someProperty = someProtocol.someProperty
        someImplementation = diContainer.resolve<SomeImplementation>()!
    }
}

extension SomeImplementation {
    init() {
        diContainer = DIContainer()
        diContainer.register<SomeProtocol>(SomeProtocol) { self }
        diContainer.register<SomeImplementation>(SomeImplementation) { self }
        someProtocol = diContainer.resolve<SomeProtocol>()!
        someProperty = someProtocol.someProperty
        someImplementation = diContainer.resolve<SomeImplementation>()!
    }
}

extension SomeProtocol {
    init() {
        diContainer = DIContainer()
        diContainer.register<SomeProtocol>(SomeProtocol) { self }
        diContainer.register<SomeImplementation>(SomeImplementation) { self }
        somePro<|fim_suffix|>
        someImplementation = diContainer.resolve<SomeImplementation>()!
    }
}

 DIContainerProtocol {
    private var _registry: [Type: Any] = {}

    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        self._registry[type] = factory
    }

    func resolve<T>(_ type: T.Type) -> T? {
        guard let factory = self._registry[type] else {
            return nil
        }
        return factory() as T
    }
}

protocol SomeProtocol {
    var someProperty: String
}

class SomeImplementation: SomeProtocol {
    override var someProperty = "Some value"
}

class SomeService {
    var someProtocol: SomeProtocol
    var someProperty: String
    var someImplementation: SomeImplementation
    var diContainer: DIContainerProtocol
}

extension SomeService {
    init() {
        diContainer = DIContainer()
        diContainer.register<SomeProtocol>(SomeProtocol) { self }
        diContainer.register<SomeImplementation>(SomeImplementation) { self }
        someProtocol = diContainer.resolve<SomeProtocol>()!
        someProperty = someProtocol.someProperty
        someImplementation = diContainer.resolve<SomeImplementation>()!
    }
}

extension SomeImplementation {
    init() {
        diContainer = DIContainer()
        diContainer.register<SomeProtocol>(SomeProtocol) { self }
        diContainer.register<SomeImplementation>(SomeImplementation) { self }
        someProtocol = diContainer.resolve<SomeProtocol>()!
        someProperty = someProtocol.someProperty
        someImplementation = diContainer.resolve<SomeImplementation>()!
    }
}

extension SomeProtocol {
    init() {
        diContainer = DIContainer()
        diContainer.register<SomeProtocol>(SomeProtocol) { self }
        diContainer.register<SomeImplementation>(SomeImplementation) { self }
        somePro<|fim_suffix|>
        someImplementation = diContainer.resolve<SomeImplementation>()!
    }
}

extension SomeImplementation {
    init() {
        diContainer = DIContainer()
        diContainer.register<SomeProtocol>(SomeProtocol) { self }
        diContainer.register<SomeImplementation>(SomeImplementation) { self }
        someProtocol = diContainer.resolve<SomeProtocol>()!
        someProperty = someProtocol.someProperty
        some<|fim_middle|>tocol = diContainer.resolve<SomeProtocol>()!<|file_separator|>

protocol DIContainerProtocol {
    func register<T>(_ type: T.Type, factory: @escaping () -> T)
    func resolve<T>(_ type: T.Type) -> T?
}

class DIContainer: DIContainerProtocol {
    private var _container: MutableDictionary<Type, Any?> = [:]
    public init() {
        self.register(Any, self)
    }
    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        self._container[type] = factory()
    }
    func resolve<T>(_ type: T.Type) -> T? {
        return self._container[type] as? T
    }
}

 DIContainerProtocol {
    private var _container: MutableDictionary<Type, Any?> = [:]
    public init() {
        self.register(Any, self)
    }
    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        self._container[type] = factory()
    }
    func resolve<T>(_ type: T.Type) -> T? {
        return self._container[type] as? T
    }
}

protocol DIContainerProtocol {
    func register<T>(_ type: T.Type, factory: @escaping () -> T)
    func resolve<T>(_ type: T.Type) -> T?
}

class DIContainer: DIContainerProtocol {
    var _container: [Type: @escaping () -> Any] = {}

    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        _container[type] = factory
    }

    func resolve<T>(_ type: T.Type) -> T? {
        if let factory = _container[type] {
            return factory() as T
        }
        return nil
    }
}

protocol SomeProtocol {
    var someProperty: String
}

class SomeClass: SomeProtocol {
    var someProperty: String = "Some value"
}

extension SomeClass {
    func someMethod() -> String {
        return "Some method result"
    }
}

extension SomeProtocol {
    func someMethod() -> String {
        return "Some protocol method result"
    }
}

extension DIContainer {
    func registerSomeProtocol<T>(_ type: T.Type, factory: @escaping () -> T) {
        register(type: T.Type, factory: factory)
    }
}

extension DIContainer {
    func resolveSomeProtocol<T>(_ type: T.Type) -> T? {
        return resolve(type: T.Type) as? T
    }
}

extension DIContainer {
    func resolveSomeClass<T>(_ type: T.Type) -> T? {
        return resolve(type: T.Type) as? T
    }
}

extension DIContainer {
    func resolveSomeProtocolAndSomeClass<T>(_ type: T.Type) -> T? {
        let someProtocol = resolveSomeProtocol<SomeProtocol>(type: T.Type)
        let someClass = resolveSomeClass<SomeClass>(type: T.Type)
        return someProtocol as? T
    }
}

 DIContainerProtocol {
    var _container: [Type: @escaping () -> Any] = {}

    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        _container[type] = factory
    }

    func resolve<T>(_ type: T.Type) -> T? {
        if let factory = _container[type] {
            return factory() as T
        }
        return nil
    }
}

protocol SomeProtocol {
    var someProperty: String
}

class SomeClass: SomeProtocol {
    var someProperty: String = "Some value"
}

extension SomeClass {
    func someMethod() -> String {
        return "Some method result"
    }
}

extension SomeProtocol {
    func someMethod() -> String {
        return "Some protocol method result"
    }
}

extension DIContainer {
    func registerSomeProtocol<T>(_ type: T.Type, factory: @escaping () -> T) {
        register(type: T.Type, factory: factory)
    }
}

extension DIContainer {
    func resolveSomeProtocol<T>(_ type: T.Type) -> T? {
        return resolve(type: T.Type) as? T
    }
}

extension DIContainer {
    func resolveSomeClass<T>(_ type: T.Type) -> T? {
        return resolve(type: T.Type) as? T
    }
}

extension DIContainer {
    func resolveSomeProtocolAndSomeClass<T>(_ type: T.Type) -> T? {
        let someProtocol = resolveSomeProtocol<SomeProtocol>(type: T.Type)
        let someClass = resolveSomeClass<SomeClass>(type: T.Type)
        return someProtocol as? T
    }
}

extension DIContainer {
    func resolveSomeProtocolAndSomeClass<T>(_ type: T.Type) -> T? {
        let someProtocol = resolveSomeProtocol<SomeProtocol>(type: T.Type)
        let someClass = resolveSomeClass<SomeClass>(type: T.Type)
        return someProtocol as? T
    }
}

extension DIContainer {
    func resolveSomeProtocolAndSomeClass<T>(_ type: T.Type) -> T? {
        let someProtocol = resolveSomeProtocol<SomeProtocol>(type: T.Type)
        let someClass = resolveSomeClass<SomeClass>(type: T.Type)
        return someProtocol as? T
    }
}

extension DIContainer {
    func resolveSomeProtocolAndSomeClass<T>(_ type: T.Type) -> T? {
        let someProtocol = resolveSomeProtocol<SomeProtocol>(type: T.Type)
        let someClass = resolveSomeClass<SomeClass>(type: T.Type)
        return someProtocol as? T
    }
}

extension DIContainer {
    func resolveSomeProtocolAndSomeClass<T>(_ type: T.Type) -> T? {
        let someProtocol = resolveSomeProtocol<SomeProtocol>(type: T.Type)
        let someClass = resolveSomeClass<SomeClass>(type: T.Type)
        return someProtocol as? T
    }
}

extension DIContainer {
    func resolveSomeProtocolAndSomeClass<T>(_ type: T.Type) -> T? {
        let someProtocol = resolveSomeProtocol<SomeProtocol>(type: T.Type)
        let someClass = resolveSomeClass<SomeClass>(type: T.Type)
        return someProtocol as? T
    }
}

extension DIContainer {
    func resolveSomeProtocolAndSomeClass<T>(_ type: T.Type) -> T? {
        let someProtocol = resolveSomeProtocol<SomeProtocol>(type: T.Type)
        let someClass = resolveSomeClass<SomeClass>(type: T.Type)
        return someProtocol as? T
    }
}

extension DIContainer {
    func resolveSomeProtocolAndSomeClass<T>(_ type: T.Type) -> T? {
        let someProtocol = resolveSomeProtocol<SomeProtocol>(type: T.Type)
        let someClass = resolveSomeClass<SomeClass>(type: T.Type)
        return someProtocol as? T
    }
}

extension DIContainer {
    func resolveSomeProtocolAndSomeClass<T>(_ type: T.Type) -> T? {
        let someProtocol = resolveSomeProtocol<SomeProtocol>(type: T.Type)
        let someClass = resolveSomeClass<SomeClass>(type: T.Type)
        return someProtocol as?

protocol DIContainerProtocol {
    func register<T>(_ type: T.Type, factory: @escaping () -> T)
    func resolve<T>(_ type: T.Type) -> T?
}

class DIContainer: DIContainerProtocol {
    private var _container = [String: Any]()

    public func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        _container[type.name] = factory
    }

    public func resolve<T>(_ type: T.Type) -> T? {
        let factory = _container[type.name] as? @escaping () -> T
        return factory?.()
    }
}

 DIContainerProtocol {
    private var _container = [String: Any]()

    public func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        _container[type.name] = factory
    }

    public func resolve<T>(_ type: T.Type) -> T? {
        let factory = _container[type.name] as? @escaping () -> T
        return factory?.()
    }
}

protocol DIContainerProtocol {
    func register<T>(_ type: T.Type, factory: @escaping () -> T)
    func resolve<T>(_ type: T.Type) -> T?
}

class DIContainer: DIContainerProtocol {
    private var _registry: [Type: @escaping () -> Any] = {}
    
    public init() {
        self.register(type: .Some, factory: { _ })
        self.register(type: .None, factory: { _ })
    }
    
    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        self._registry[type] = factory
    }
    
    func resolve<T>(_ type: T.Type) -> T? {
        guard let factory = self._registry[type] else {
            return nil
        }
        
        return factory() as T
    }
}

class Some {
    var value: String?
}

class None {
    var value: String?
}

class SomeService {
    var some: Some?
}

class NoneService {
    var none: None?
}

class SomeServiceDI {
    var container: DIContainerProtocol
    var someService: SomeService?
    
    init(container: DIContainerProtocol) {
        self.container = container
        self.someService = container.resolve<SomeService>()
    }
}

class NoneServiceDI {
    var container: DIContainerProtocol
    var noneService: NoneService?
    
    init(container: DIContainerProtocol) {
        self.container = container
        self.noneService = container.resolve<NoneService>()
    }
}

 DIContainerProtocol {
    private var _registry: [Type: @escaping () -> Any] = {}
    
    public init() {
        self.register(type: .Some, factory: { _ })
        self.register(type: .None, factory: { _ })
    }
    
    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        self._registry[type] = factory
    }
    
    func resolve<T>(_ type: T.Type) -> T? {
        guard let factory = self._registry[type] else {
            return nil
        }
        
        return factory() as T
    }
}

class Some {
    var value: String?
}

class None {
    var value: String?
}

class SomeService {
    var some: Some?
}

class NoneService {
    var none: None?
}

class SomeServiceDI {
    var container: DIContainerProtocol
    var someService: SomeService?
    
    init(container: DIContainerProtocol) {
        self.container = container
        self.someService = container.resolve<SomeService>()
    }
}

class NoneServiceDI {
    var container: DIContainerProtocol
    var noneService: NoneService?
    
    init(container: DIContainerProtocol) {
        self.container = container
        self.noneService = container.resolve<NoneService>()
    }
}

let container = DIContainer()
let someServiceDI = SomeServiceDI(container: container)
let noneServiceDI = NoneServiceDI(container: container)

someServiceDI.someService?.some = Some(value: "some")
someServiceDI.someService?.some = nil
noneServiceDI.noneService?.none = None(value: "none")
noneServiceDI.noneService?.none = nil

print(someServiceDI.someService?.some?.value) // "some"
print(someServiceDI.someService?.some?.value) // nil
print(noneServiceDI.noneService?.none?.value) // "none"
print(noneServiceDI.noneService?.none?.value) // nil

protocol DIContainerProtocol {
    func register<T>(_ type: T.Type, factory: @escaping () -> T)
    func resolve<T>(_ type: T.Type) -> T?
}

class DIContainer: DIContainerProtocol {
    private var _container: Map<Type, @escaping () -> Any?> = Map()

    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        _container[type] = factory
    }

    func resolve<T>(_ type: T.Type) -> T? {
        return _container[type]() as? T
    }
}

class User {
    var id: Int
    var name: String
    var age: Int
    var address: String
    var phone: String
}

protocol UserRepositoryProtocol {
    func getUser(_ id: Int) -> User?
}

class UserRepository: UserRepositoryProtocol {
    var database: Map<Int, User> = Map()

    func getUser(_ id: Int) -> User? {
        return database[id]
    }
}

class UserController {
    var userRepository: UserRepositoryProtocol
    var diContainer: DIContainerProtocol

    init() {
        diContainer = DIContainer()
        diContainer.register<UserRepositoryProtocol>(UserRepository)
        userRepository = diContainer.resolve<UserRepositoryProtocol>()!
    }

    func getUser(_ id: Int) -> User? {
        return userRepository.getUser(id)
    }
}

 DIContainerProtocol {
    private var _container: Map<Type, @escaping () -> Any?> = Map()

    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        _container[type] = factory
    }

    func resolve<T>(_ type: T.Type) -> T? {
        return _container[type]() as? T
    }
}

class User {
    var id: Int
    var name: String
    var age: Int
    var address: String
    var phone: String
}

protocol UserRepositoryProtocol {
    func getUser(_ id: Int) -> User?
}

class UserRepository: UserRepositoryProtocol {
    var database: Map<Int, User> = Map()

    func getUser(_ id: Int) -> User? {
        return database[id]
    }
}

class UserController {
    var userRepository: UserRepositoryProtocol
    var diContainer: DIContainerProtocol

    init() {
        diContainer = DIContainer()
        diContainer.register<UserRepositoryProtocol>(UserRepository)
        userRepository = diContainer.resolve<UserRepositoryProtocol>()!
    }

    func getUser(_ id: Int) -> User? {
        return userRepository.getUser(id)
    }
}

protocol DIContainerProtocol {
    func register<T>(_ type: T.Type, factory: @escaping () -> T)
    func resolve<T>(_ type: T.Type) -> T?
}

class DIContainer: DIContainerProtocol {
    private var _registry: [Type: Any] = {}

    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        _registry[type] = factory
    }

    func resolve<T>(_ type: T.Type) -> T? {
        let factory = _registry[type] as? @escaping () -> T
        return factory?.()
    }
}

class ServiceA {
    var serviceB: ServiceB
    var serviceC: ServiceC
}

class ServiceB {
    var serviceC: ServiceC
}

class ServiceC {
    var serviceA: ServiceA
}

extension ServiceA {
    init() {
        serviceB = resolve()
        serviceC = resolve()
    }
}

extension ServiceB {
    init() {
        serviceC = resolve()
    }
}

extension ServiceC {
    init() {
        serviceA = resolve()
    }
}

 DIContainerProtocol {
    private var _registry: [Type: Any] = {}

    func register<T>(_ type: T.Type, factory: @escaping () -> T) {
        _registry[type] = factory
    }

    func resolve<T>(_ type: T.Type) -> T? {
        let factory = _registry[type] as? @escaping () -> T
        return factory?.()
    }
}

class ServiceA {
    var serviceB: ServiceB
    var serviceC: ServiceC
}

class ServiceB {
    var serviceC: ServiceC
}

class ServiceC {
    var serviceA: ServiceA
}

extension ServiceA {
    init() {
        serviceB = resolve()
        serviceC = resolve()
    }
}

extension ServiceB {
    init() {
        serviceC = resolve()
    }
}

extension ServiceC {
    init() {
        serviceA = resolve()
    }
}

let diContainer = DIContainer()
diContainer.register(ServiceA.self)
diContainer.register(ServiceB.self)
diContainer.register(ServiceC.self)

let serviceA = ServiceA()
print(serviceA.serviceB.serviceC.serviceA.serviceC)

protocol StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State)
    var state: State { get }
    func trigger(event: Event)
    func registerTransition(from: State, to: State, event: Event)
}

class StateMachine<State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State: [Event: State]] = [:]
    
    init(state: State) {
        self.state = state
    }
    
    func trigger(event: Event) {
        let nextState = transitions[state][event]
        if let nextState = nextState {
            state = nextState
        }
    }
    
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

protocol StateProtocol {
    associatedtype Event: Hashable
    var name: String
    func trigger(event: Event)
}

class State<Event: Hashable>: StateProtocol {
    public var name: String
    public var transitions: [Event: StateProtocol] = [:]
    
    init(name: String) {
        self.name = name
    }
    
    func trigger(event: Event) {
        let nextState = transitions[event]
        if let nextState = nextState {
            nextState.trigger(event)
        }
    }
}

class Event<Event: Hashable>: StateProtocol {
    public var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func trigger() {
        print("Event triggered: \(name)")
    }
}

State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State: [Event: State]] = [:]
    
    init(state: State) {
        self.state = state
    }
    
    func trigger(event: Event) {
        let nextState = transitions[state][event]
        if let nextState = nextState {
            state = nextState
        }
    }
    
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

protocol StateProtocol {
    associatedtype Event: Hashable
    var name: String
    func trigger(event: Event)
}

class State<Event: Hashable>: StateProtocol {
    public var name: String
    public var transitions: [Event: StateProtocol] = [:]
    
    init(name: String) {
        self.name = name
    }
    
    func trigger(event: Event) {
        let nextState = transitions[event]
        if let nextState = nextState {
            nextState.trigger(event)
        }
    }
}

class Event<Event: Hashable>: StateProtocol {
    public var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func trigger() {
        print("Event triggered: \(name)")
    }
}

let stateMachine = StateMachine<State, Event><|fim_suffix|>
<|fim_middle|>(state: State("Initial"))
let state1 = State("State 1")
let state2 = State("State 2")
let state3 = State("State 3")
let event1 = Event("Event 1")
let event2 = Event("Event 2")
let event3 = Event("Event 3")

stateMachine.registerTransition(from: state1, to: state2, event: event1)
stateMachine.registerTransition(from: state2, to: state3, event: event2)
stateMachine.registerTransition(from: state3, to: state1, event: event3)

stateMachine.trigger(event: event1)
stateMachine.trigger(event: event2)
stateMachine.trigger(event: event3)

protocol StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State)
    var state: State { get }
    func trigger(event: Event)
    func registerTransition(from: State, to: State, event: Event)
}

State: Hashable, Event: Hashable>: StateMachineProtocol {
    public let state: State
    private var _transitions: [State, Event, State]?[State, Event, State]
    
    init(state: State) {
        self.state = state
    }
    
    func trigger(event: Event) {
        guard _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _transitions?[self.state, event, _

protocol StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State)
    var state: State { get }
    func trigger(event: Event)
    func registerTransition(from: State, to: State, event: Event)
}

class StateMachine<State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    private var eventQueue: [Event]
    
    public init(state: State) {
        self.state = state
        self.transitions = []
        self.eventQueue = []
    }
    
    public func trigger(event: Event) {
        self.eventQueue.append(event)
        while let event in self.eventQueue {
            for transition in self.transitions {
                if transition.0 == self.state && transition.1 == event {
                    self.state = transition.2
                    self.eventQueue = []
                    break
                }
            }
        }
    }
    
    public func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func trigger(event: Event) {
        self.trigger(event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func registerTransition(from: State, to: State, event: Event) {
        self.registerTransition(from, to, event)
    }
}

State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    private var eventQueue: [Event]
    
    public init(state: State) {
        self.state = state
        self.transitions = []
        self.eventQueue = []
    }
    
    public func trigger(event: Event) {
        self.eventQueue.append(event)
        while let event in self.eventQueue {
            for transition in self.transitions {
                if transition.0 == self.state && transition.1 == event {
                    self.state = transition.2
                    self.eventQueue = []
                    break
                }
            }
        }
    }
    
    public func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func trigger(event: Event) {
        self.trigger(event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func registerTransition(from: State, to: State, event: Event) {
        self.registerTransition(from, to, event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func registerTransition(from: State, to: State, event: Event) {
        self.registerTransition(from, to, event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func trigger(event: Event) {
        self.trigger(event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func registerTransition(from: State, to: State, event: Event) {
        self.registerTransition(from, to, event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func trigger(event: Event) {
        self.trigger(event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func registerTransition(from: State, to: State, event: Event) {
        self.registerTransition(from, to, event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func trigger(event: Event) {
        self.trigger(event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func registerTransition(from: State, to: State, event: Event) {
        self.registerTransition(from, to, event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func trigger(event: Event) {
        self.trigger(event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func registerTransition(from: State, to: State, event: Event) {
        self.registerTransition(from, to, event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func trigger(event: Event) {
        self.trigger(event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func registerTransition(from: State, to: State, event: Event) {
        self.registerTransition(from, to, event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func trigger(event: Event) {
        self.trigger(event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func registerTransition(from: State, to: State, event: Event) {
        self.registerTransition(from, to, event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func trigger(event: Event) {
        self.trigger(event)
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    public func registerTransition(from: State, to: State, event: Event) {
        self.registerTransition(from, to, event)
    }
}

exte

protocol StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State)
    var state: State { get }
    func trigger(event: Event)
    func registerTransition(from: State, to: State, event: Event)
}

class StateMachine<State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State: [Event: State]] = [:]
    
    init(state: State) {
        self.state = state
    }
    
    func trigger(event: Event) {
        let nextState = transitions[state][event]
        if nextState != nil {
            state = nextState
        }
    }
    
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func trigger(event: Event) {
        let nextState = transitions[state][event]
        if nextState != nil {
            state = nextState
        }
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    init(state: State) {
        self.state = state
    }
}

State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State: [Event: State]] = [:]
    
    init(state: State) {
        self.state = state
    }
    
    func trigger(event: Event) {
        let nextState = transitions[state][event]
        if nextState != nil {
            state = nextState
        }
    }
    
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func trigger(event: Event) {
        let nextState = transitions[state][event]
        if nextState != nil {
            state = nextState
        }
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    init(state: State) {
        self.state = state
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func trigger(event: Event) {
        let nextState = transitions[state][event]
        if nextState != nil {
            state = nextState
        }
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        transitions[from][event] = to
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to:

protocol StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State)
    var state: State { get }
    func trigger(event: Event)
    func registerTransition(from: State, to: State, event: Event)
}

class StateMachine<State: Hashable, Event: Hashable>: StateMachineProtocol {
    public let state: State
    private var transitions: Map<State, Map<Event, State>> = Map()
    
    public init(state: State) {
        self.state = state
    }
    
    public func trigger(event: Event) {
        let nextState = transitions[state]?.get(event)
        if let nextState = nextState {
            state = nextState
        }
    }
    
    public func registerTransition(from: State, to: State, event: Event) {
        let transitionsForState = transitions[from] ?? Map()
        transitionsForState[event] = to
        transitions[from] = transitionsForState
    }
}

extension StateMachineProtocol {
    func trigger(event: Event) {
        self.trigger(event)
    }
}

class StateMachineTest: StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State) {
        self.state = state
    }
    
    var state: State { get }
    func trigger(event: Event) {
        self.state = event
    }
    
    func registerTransition(from: State, to: State, event: Event) {
        self.state = event
    }
}

State: Hashable, Event: Hashable>: StateMachineProtocol {
    public let state: State
    private var transitions: Map<State, Map<Event, State>> = Map()
    
    public init(state: State) {
        self.state = state
    }
    
    public func trigger(event: Event) {
        let nextState = transitions[state]?.get(event)
        if let nextState = nextState {
            state = nextState
        }
    }
    
    public func registerTransition(from: State, to: State, event: Event) {
        let transitionsForState = transitions[from] ?? Map()
        transitionsForState[event] = to
        transitions[from] = transitionsForState
    }
}

extension StateMachineProtocol {
    func trigger(event: Event) {
        self.trigger(event)
    }
}

class StateMachineTest: StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State) {
        self.state = state
    }
    
    var state: State { get }
    func trigger(event: Event) {
        self.state = event
    }
    
    func registerTransition(from: State, to: State, event: Event) {
        self.state = event
    }
}

extension StateMachineProtocol {
    func trigger(event: Event) {
        self.trigger(event)
    }
}

class StateMachineTest: StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State) {
        self.state = state
    }
    
    var state: State { get }
    func trigger(event: Event) {
        self.state = event
    }
    
    func registerTransition(from: State, to: State, event: Event) {
        self.state = event
    }
}

extension StateMachineProtocol {
    func trigger(event: Event) {
        self.trigger(event)
    }
}

class StateMachineTest: StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State) {
        self.state = state
    }
    
    var state: State { get }
    func trigger(event: Event) {
        self.state = event
    }
    
    func registerTransition(from: State, to: State, event: Event) {
        self.state = event
    }
}

extension StateMachineProtocol {
    func trigger(event: Event) {
        self.trigger(event)
    }
}

class StateMachineTest: StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State) {
        self.state = state
    }
    
    var state: State { get }
    func trigger(event: Event) {
        self.state = event
    }
    
    func registerTransition(from: State, to: State, event: Event) {
        self.state = event
    }
}

extension StateMachineProtocol {
    func trigger(event: Event) {
        self.trigger(event)
    }
}

class StateMachineTest: StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State) {
        self.state = state
    }
    
    var state: State { get }
    func trigger(event: Event) {
        self.state = event
    }
    
    func registerTransition(from: State, to: State, event: Event) {
        self.state = event
    }
}

extension StateMachineProtocol {
    func trigger(event: Event) {
        self.trigger(event)
    }
}

class StateMachineTest: StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State) {
        self.state = state
    }
    
    var state: State { get }
    func trigger(event: Event) {
        self.state = event
    }
    
    func registerTransition(from: State, to: State, event: Event) {
        self.state = event
    }
}

extension StateMachineProtocol {
    func trigger(event: Event) {
        self.trigger(event)

protocol StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State)
    var state: State { get }
    func trigger(event: Event)
    func registerTransition(from: State, to: State, event: Event)
}

class StateMachine<State: Hashable, Event: Hashable>: StateMachineProtocol {
    var state: State
    var transitions: [State, Event, State]
    var stateMap: Map<State, State>
    var eventMap: Map<Event, State>

    init(state: State) {
        self.state = state
        self.transitions = []
        self.stateMap = Map<State, State>()
        self.eventMap = Map<Event, State>()
    }

    func trigger(event: Event) {
        let newState = self.eventMap[event]
        if newState != nil {
            self.state = newState
        }
    }

    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append(from: from, to: to, event: event)
        self.stateMap[from] = to
        self.eventMap[event] = to
    }
}

State: Hashable, Event: Hashable>: StateMachineProtocol {
    var state: State
    var transitions: [State, Event, State]
    var stateMap: Map<State, State>
    var eventMap: Map<Event, State>

    init(state: State) {
        self.state = state
        self.transitions = []
        self.stateMap = Map<State, State>()
        self.eventMap = Map<Event, State>()
    }

    func trigger(event: Event) {
        let newState = self.eventMap[event]
        if newState != nil {
            self.state = newState
        }
    }

    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append(from: from, to: to, event: event)
        self.stateMap[from] = to
        self.eventMap[event] = to
    }
}

let stateMachine = StateMachine<State, Event>(state: State.A)
stateMachine.trigger(event: Event.B)
stateMachine.trigger(event: Event.C)
stateMachine.trigger(event: Event.D)
stateMachine.trigger(event: Event.E)
stateMachine.trigger(event: Event.F)
stateMachine.trigger(event: Event.G)
stateMachine.trigger(event: Event.H)
stateMachine.trigger(event: Event.I)
stateMachine.trigger(event: Event.J)
stateMachine.trigger(event: Event.K)
stateMachine.trigger(event: Event.L)
stateMachine.trigger(event: Event.M)
stateMachine.trigger(event: Event.N)
stateMachine.trigger(event: Event.O)
stateMachine.trigger(event: Event.P)
stateMachine.trigger(event: Event.Q)
stateMachine.trigger(event: Event.R)
stateMachine.trigger(event: Event.S)
stateMachine.trigger(event: Event.T)
stateMachine.trigger(event: Event.U)
stateMachine.trigger(event: Event.V)
stateMachine.trigger(event: Event.W)
stateMachine.trigger(event: Event.X)
stateMachine.trigger(event: Event.Y)
stateMachine.trigger(event: Event.Z)
stateMachine.trigger(event: Event.a)
stateMachine.trigger(event: Event.b)
stateMachine.trigger(event: Event.c)
stateMachine.trigger(event: Event.d)
stateMachine.trigger(event: Event.e)
stateMachine.trigger(event: Event.f)
stateMachine.trigger(event: Event.g)
stateMachine.trigger(event: Event.h)
stateMachine.trigger(event: Event.i)
stateMachine.trigger(event: Event.j)
stateMachine.trigger(event: Event.k)
stateMachine.trigger(event: Event.l)
stateMachine.trigger(event: Event.m)
stateMachine.trigger(event: Event.n)
stateMachine.trigger(event: Event.o)
stateMachine.trigger(event: Event.p)
stateMachine.trigger(event: Event.q)
stateMachine.trigger(event: Event.r)
stateMachine.trigger(event: Event.s)
stateMachine.trigger(event: Event.t)
stateMachine.trigger(event: Event.u)
stateMachine.trigger(event: Event.v)
stateMachine.trigger(event: Event.w)
stateMachine.trigger(event: Event.x)
stateMachine.trigger(event: Event.y)
stateMachine.trigger(event: Event.z)
stateMachine.trigger(event: Event.A)
stateMachine.trigger(event: Event.B)
stateMachine.trigger(event: Event.C)
stateMachine.trigger(event: Event.D)
stateMachine.trigger(event: Event.E)
stateMachine.trigger(event: Event.F)
stateMachine.trigger(event: Event.G)
stateMachine.trigger(event: Event.H)
stateMachine.trigger(event: Event.I)
stateMachine.trigger(event: Event.J)
stateMachine.trigger(event: Event.K)
stateMachine.trigger(event: Event.L)
stateMachine.trigger(event: Event.M)
stateMachine.trigger(event: Event.N)
stateMachine.trigger(event: Event.

protocol StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State)
    var state: State { get }
    func trigger(event: Event)
    func registerTransition(from: State, to: State, event: Event)
}

class StateMachine<State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    
    init(state: State) {
        self.state = state
        self.transitions = []
    }
    
    func trigger(event: Event) {
        let newState = self.transitions.first {
            $0 == self.state && $1 == event
        }
        if newState != nil {
            self.state = newState
        }
    }
    
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func trigger(event: Event) {
        let newState = self.transitions.first {
            $0 == self.state && $1 == event
        }
        if newState != nil {
            self.state = newState
        }
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    
    init(state: State) {
        self.state = state
        self.transitions = []
    }
    
    func trigger(event: Event) {
        let newState = self.transitions.first {
            $0 == self.state && $1 == event
        }
        if newState != nil {
            self.state = newState
        }
    }
    
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func trigger(event: Event) {
        let newState = self.transitions.first {
            $0 == self.state && $1 == event
        }
        if newState != nil {
            self.state = newState
        }
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func registerTransition(from: State, to: State, event:

protocol StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State)
    var state: State { get }
    func trigger(event: Event)
    func registerTransition(from: State, to: State, event: Event)
}

class StateMachine<State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    private var eventQueue: [Event]

    init(state: State) {
        self.state = state
        self.transitions = []
        self.eventQueue = []
    }

    func trigger(event: Event) {
        if let transition = self.transitions.firstWhere({
            $0.state == self.state && $0.event == event
        }) {
            self.state = transition.to
            self.transitions.removeFirst()
        } else {
            self.eventQueue.append(event)
        }
    }

    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func run() {
        while let event = self.eventQueue.first {
            self.trigger(event)
        }
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func runUntil(condition: () -> Bool) {
        while condition() {
            self.run()
        }
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func runUntil(condition: () -> Bool, onCompletion: () -> Void) {
        while condition() {
            self.run()
        }
        onCompletion()
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func runUntil(condition: () -> Bool, onCompletion: () -> Void, onTimeout: () -> Void) {
        var timeout = 0
        while condition() {
            self.run()
            timeout += 1
            if timeout > 100 {
                onTimeout()
                break
            }
        }
        onCompletion()
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func runUntil(condition: () -> Bool, onCompletion: () -> Void, onTimeout: () -> Void, onTimeoutDuration: Int) {
        var timeout = 0
        while condition() {
            self.run()
            timeout += 1
            if timeout > onTimeoutDuration {
                onTimeout()
                break
            }
        }
        onCompletion()
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func runUntil(condition: () -> Bool, onCompletion: () -> Void, onTimeout: () -> Void, onTimeoutDuration: Int, onTimeoutDurationUnit: TimeUnit) {
        var timeout = 0
        while condition() {
            self.run()
            timeout += 1
            if timeout > onTimeoutDuration {
                onTimeout()
                break
            }
        }
        onCompletion()
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func runUntil(condition: () -> Bool, onCompletion: () -> Void, onTimeout: () -> Void, onTimeoutDuration: Int, onTimeoutDurationUnit: TimeUnit, onTimeoutDurationUnit: TimeUnit) {
        var timeout = 0
        while condition() {
            self.run()
            timeout += 1
            if timeout > onTimeoutDuration {
                onTimeout()
                break
            }
        }
        onCompletion()
    }
}

State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    private var eventQueue: [Event]

    init(state: State) {
        self.state = state
        self.transitions = []
        self.eventQueue = []
    }

    func trigger(event: Event) {
        if let transition = self.transitions.firstWhere({
            $0.state == self.state && $0.event == event
        }) {
            self.state = transition.to
            self.transitions.removeFirst()
        } else {
            self.eventQueue.append(event)
        }
    }

    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func run() {
        while let event = self.eventQueue.first {
            self.trigger(event)
        }
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func runUntil(condition: () -> Bool) {
        while condition() {
            self.run()
        }
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func runUntil(condition: () -> Bool, onCompletion: () -> Void) {
        while condition() {
            self.run()
        }
        onCompletion()
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func runUntil(condition: () -> Bool, onCompletion: () -> Void, onTimeout: () -> Void) {
        var timeout = 0
        while condition() {
            self.run()
            timeout += 1
            if timeout > 100 {
                onTimeout()
                break
            }
        }
        onCompletion()
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func runUntil(condition: () -> Bool, onCompletion: () -> Void, onTimeout: () -> Void, onTimeoutDuration: Int) {
        var timeout = 0
        while condition() {
            self.run()
            timeout += 1
            if timeout > onTimeoutDuration {
                onTimeout()
                break
            }
        }
        onCompletion()
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func runUntil(condition: () -> Bool, onCompletion: () -> Void, onTimeout: () -> Void, onTimeoutDuration: Int, onTimeoutDurationUnit: TimeUnit) {
        var timeout = 0
        while condition() {
            self.run()
            timeout += 1
            if timeout > onTimeoutDuration {
                onTimeout()
                break
            }
        }
        onCompletion()
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func runUntil(condition: () -> Bool, onCompletion: () -> Void, onTimeout: () -> Void, onTimeoutDuration: Int, onTimeoutDurationUnit: TimeUnit, onTimeoutDurationUnit: TimeUnit) {
        var timeout = 0
        while condition() {
            self.run()
            timeout += 1
            if timeout > onTimeoutDuration {
                onTimeout()
                break
            }
        }
        onCompletion()
    }
}

extension StateMachine<State: Hashable, Event: Hashable> {
    func runUntil(condition: () -> Bool, onCompletion: () -> Void, onTimeout: () -> Void, onTimeoutDuration: Int, onTimeoutDurationUnit: TimeUnit, onTimeoutDurationUnit: TimeUnit, onTimeoutDurationUnit: TimeUnit) {
        var timeout = 0
        while condition() {
            self.run()
            timeout += 1
       <|fim_middle|># %%
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Finite state machine with possibility to register custom transitions between states.
### Response:

protocol StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State)
    var state: State { get }
    func trigger(event: Event)
    func registerTransition(from: State, to: State, event: Event)
}

class StateMachine<State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    private var eventQueue: [Event]

    init(state: State) {
        self.state = state
        self.transitions = []
        self.eventQueue = []
    }

    func trigger(event: Event) {
        guard let transition = self.transitions.firstWhere({
            $0.state == self.state && $0.event == event
        }) else {
            fatalError("No transition found for state: \(self.state) and event: \(event)")
        }
        self.state = transition.to
        self.eventQueue = []
    }

    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }

    func triggerEvent(event: Event) {
        self.eventQueue.append(event)
        while let event in self.eventQueue {
            self.trigger(event)
        }
    }
}

State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    private var eventQueue: [Event]

    init(state: State) {
        self.state = state
        self.transitions = []
        self.eventQueue = []
    }

    func trigger(event: Event) {
        guard let transition = self.transitions.firstWhere({
            $0.state == self.state && $0.event == event
        }) else {
            fatalError("No transition found for state: \(self.state) and event: \(event)")
        }
        self.state = transition.to
        self.eventQueue = []
    }

    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }

    func triggerEvent(event: Event) {
        self.eventQueue.append(event)
        while let event in self.eventQueue {
            self.trigger(event)
        }
    }
}

protocol StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State)
    var state: State { get }
    func trigger(event: Event)
    func registerTransition(from: State, to: State, event: Event)
}

class StateMachine<State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    private var eventQueue: [Event]

    init(state: State) {
        self.state = state
        self.transitions = []
        self.eventQueue = []
    }

    func trigger(event: Event) {
        guard let transition = self.transitions.firstWhere({
            $0.state == self.state && $0.event == event
        }) else {
            fatalError("No transition found for state: \(self.state) and event: \(event)")
        }
        self.state = transition.to
        self.eventQueue = []
    }

    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }

    func triggerEvent(event: Event) {
        self.eventQueue.append(event)
        while let event in self.eventQueue {
            self.trigger(event)
        }
    }
}

protocol StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State)
    var state: State { get }
    func trigger(event: Event)
    func registerTransition(from: State, to: State, event: Event)
}

class StateMachine<State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    private var eventQueue: [Event]

    init(state: State) {
        self.state = state
        self.transitions = []
        self.eventQueue = []
    }

    func trigger(event: Event) {
        guard let transition = self.transitions.firstWhere({
            $0.state == self.state && $0.event == event
        }) else {
            fatalError("No transition found for state: \(self.state) and event: \(event)")
        }
        self.state = transition.to
        self.eventQueue = []
    }

    func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }

    func triggerEvent(event: Event) {
        self.eventQueue.append(event)
        while let event in self.eventQueue {
            self.trigger(event)
        }
    }
}

protocol StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State)
    var state: State { get }
    func trigger(event: Event)
    func registerTransition(from: State, to: State, event: Event)
}

class StateMachine<State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    private var eventQueue: [Event]

    init(state

protocol StateMachineProtocol {
    associatedtype State: Hashable
    associatedtype Event: Hashable
    init(state: State)
    var state: State { get }
    func trigger(event: Event)
    func registerTransition(from: State, to: State, event: Event)
}

class StateMachine<State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    private var listeners: [State, Event, State]

    public init(state: State) {
        self.state = state
        self.transitions = []
        self.listeners = []
    }

    public func trigger(event: Event) {
        let transition = self.transitions.first { $0.0 == $1.0 && $0.2 == $2.0 }
        if let transition = transition {
            self.state = transition.1
            self.listeners.forEach { $0.0 == $1.0 && $0.2 == $2.0 { $0.1($1, $2) } }
        }
    }

    public func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }

    public func registerListener(listener: (State, Event, State) -> ()) {
        self.listeners.append(listener)
    }
}

class TestStateMachine: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    private var listeners: [State, Event, State]

    public init(state: State) {
        self.state = state
        self.transitions = []
        self.listeners = []
    }

    public func trigger(event: Event) {
        let transition = self.transitions.first { $0.0 == $1.0 && $0.2 == $2.0 }
        if let transition = transition {
            self.state = transition.1
            self.listeners.forEach { $0.0 == $1.0 && $0.2 == $2.0 { $0.1($1, $2) } }
        }
    }

    public func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }

    public func registerListener(listener: (State, Event, State) -> ()) {
        self.listeners.append(listener)
    }
}

extension TestStateMachine {
    public func test(from: State, event: Event, to: State) {
        self.registerTransition(from, to, event)
    }

    public func testListener(listener: (State, Event, State) -> ()) {
        self.registerListener(listener)
    }
}

State: Hashable, Event: Hashable>: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    private var listeners: [State, Event, State]

    public init(state: State) {
        self.state = state
        self.transitions = []
        self.listeners = []
    }

    public func trigger(event: Event) {
        let transition = self.transitions.first { $0.0 == $1.0 && $0.2 == $2.0 }
        if let transition = transition {
            self.state = transition.1
            self.listeners.forEach { $0.0 == $1.0 && $0.2 == $2.0 { $0.1($1, $2) } }
        }
    }

    public func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }

    public func registerListener(listener: (State, Event, State) -> ()) {
        self.listeners.append(listener)
    }
}

class TestStateMachine: StateMachineProtocol {
    public var state: State
    private var transitions: [State, Event, State]
    private var listeners: [State, Event, State]

    public init(state: State) {
        self.state = state
        self.transitions = []
        self.listeners = []
    }

    public func trigger(event: Event) {
        let transition = self.transitions.first { $0.0 == $1.0 && $0.2 == $2.0 }
        if let transition = transition {
            self.state = transition.1
            self.listeners.forEach { $0.0 == $1.0 && $0.2 == $2.0 { $0.1($1, $2) } }
        }
    }

    public func registerTransition(from: State, to: State, event: Event) {
        self.transitions.append([from, event, to])
    }

    public func registerListener(listener: (State, Event, State) -> ()) {
        self.listeners.append(listener)
    }
}

extension TestStateMachine {
    public func test(from: State, event: Event, to: State) {
        self.registerTransition(from, to, event)
    }

    public func testListener(listener: (State, Event, State) -> ()) {
        self.registerListener(listener)
    }
}

let stateMachine = TestStateMachine(State.A)

stateMachine.test(State.A, Event.A, State.B)
stateMachine.test(State.B, Event.B, State.C)
stateMachine.test(State.C, Event.C, State.A)

stateMachine.testListener { state, event, newState ->
    print("State changed from: \(state) to: \(newState) with event: \(event)")
}

print("Current state: \(stateMachine.state)")

indirect enum FileSystemNode {
    case file(name: String, size: Int)
    case directory(name: String, contents: [FileSystemNode])
}

protocol FileSystemInfo {
    var totalSize: Int { get }
    var filesCount: Int { get }
    var treeDepth: Int { get }
}

extension FileSystemNode: FileSystemInfo {
    var totalSize: Int { get } {
        var totalSize = 0
        switch self {
            case let file(size: Int) {
                totalSize += size
            }
            case let directory(contents: [FileSystemNode]) {
                for content in contents {
                    totalSize += content.totalSize
                }
            }
        }
        return totalSize
    }
}

extension FileSystemInfo {
    var filesCount: Int { get } {
        var filesCount = 0
        switch self {
            case let file() {
                filesCount += 1
            }
            case let directory(contents: [FileSystemNode]) {
                for content in contents {
                    filesCount += content.filesCount
                }
            }
        }
        return filesCount
    }
}

extension FileSystemInfo {
    var treeDepth: Int { get } {
        var treeDepth = 0
        switch self {
            case let file() {
                treeDepth += 0
            }
            case let directory(contents: [FileSystemNode]) {
                for content in contents {
                    treeDepth = max(treeDepth, content.treeDepth + 1)
                }
            }
        }
        return treeDepth
    }
}

extension FileSystemInfo {
    var totalSize: Int { get } {
        return self.totalSize
    }
}

extension FileSystemInfo {
    var filesCount: Int { get } {
        return self.filesCount
    }
}

extension FileSystemInfo {
    var treeDepth: Int { get } {
        return self.treeDepth
    }
}

extension FileSystemNode {
    var totalSize: Int { get } {
        return self.totalSize
    }
}

extension FileSystemNode {
    var filesCount: Int { get } {
        return self.filesCount
    }
}

extension FileSystemNode {
    var treeDepth: Int { get } {
        return self.treeDepth
    }
}

    var totalSize: Int { get } {
        var totalSize = 0
        switch self {
            case let file(size: Int) {
                totalSize += size
            }
            case let directory(contents: [FileSystemNode]) {
                for content in contents {
                    totalSize += content.totalSize
                }
            }
        }
        return totalSize
    }
}

extension FileSystemInfo {
    var filesCount: Int { get } {
        var filesCount = 0
        switch self {
            case let file() {
                filesCount += 1
            }
            case let directory(contents: [FileSystemNode]) {
                for content in contents {
                    filesCount += content.filesCount
                }
            }
        }
        return filesCount
    }
}

extension FileSystemInfo {
    var treeDepth: Int { get } {
        var treeDepth = 0
        switch self {
            case let file() {
                treeDepth += 0
            }
            case let directory(contents: [FileSystemNode]) {
                for content in contents {
                    treeDepth = max(treeDepth, content.treeDepth + 1)
                }
            }
        }
        return treeDepth
    }
}

extension FileSystemInfo {
    var totalSize: Int { get } {
        return self.totalSize
    }
}

extension FileSystemInfo {
    var filesCount: Int { get } {
        return self.filesCount
    }
}

extension FileSystemInfo {
    var treeDepth: Int { get } {
        return self.treeDepth
    }
}

extension FileSystemNode {
    var totalSize: Int { get } {
        return self.totalSize
    }
}

extension FileSystemNode {
    var filesCount: Int { get } {
        return self.filesCount
    }
}

extension FileSystemNode {
    var treeDepth: Int { get } {
        return self.treeDepth
    }
}

extension FileSystemNode {
    var totalSize: Int { get } {
        return self.totalSize
    }
}

extension FileSystemNode {
    var filesCount: Int { get } {
        return self.filesCount
    }
}

extension FileSystemNode {
    var treeDepth: Int { get } {
        return self.treeDepth
    }
}

extension FileSystemNode {
    var totalSize: Int { get } {
        return self.totalSize
    }
}

extension FileSystemNode {
    var filesCount: Int { get } {
        return self.filesCount
    }
}

extension FileSystemNode {
    var treeDepth: Int { get } {
        return self.treeDepth
    }
}

extension FileSystemNode {
    var totalSize: Int { get } {
        return self.totalSize
    }
}

extension FileSystemNode {
    var filesCount: Int { get } {
        return self.filesCount
    }
}

extension FileSystemNode {
    var treeDepth: Int { get } {
        return self.treeDepth
    }
}

extension FileSystemNode {
    var totalSize: Int { get } {
        return self.totalSize
    }
}

extension FileSystemNode {
    var filesCount: Int { get } {
        return self.filesCount
    }
}

extension FileSystemNode {
    var treeDepth: Int { get } {
        return self.treeDepth
    }
}

extension FileSystemNode {
    var totalSize: Int { get } {
        return self.totalSize
    }
}

extension FileSystemNode {
    var filesCount: Int { get } {
        return self.filesCount
    }
}

extension FileSystemNode {
    var treeDepth: Int { get } {
        return self.treeDepth
    }
}

extension FileSystemNode {
    var totalSize: Int { get } {
        return self.totalSize
    }
}

extension FileSystemNode {
    var filesCount: Int { get } {
        return self.filesCount
    }
}

extension FileSystemNode {
    var treeDepth: Int { get } {
        return self.treeDepth
    }
}

extension FileSystemNode {
    var totalSize: Int { get } {
        return self.totalSize
    }
}

extension FileSystemNode {
    var filesCount: Int { get } {
        return self.filesCount
    }
}

extension FileSystemNode {
    

indirect enum FileSystemNode {
    case file(name: String, size: Int)
    case directory(name: String, contents: [FileSystemNode])
}

protocol FileSystemInfo {
    var totalSize: Int { get }
    var filesCount: Int { get }
    var treeDepth: Int { get }
}

extension FileSystemNode: FileSystemInfo {
    var totalSize: Int { get } {
        var totalSize = 0
        if let file = self as? .file {
            totalSize += file.size
        } else if let directory = self as? .directory {
            totalSize += directory.contents.map { it.totalSize }.sum()
        }
        return totalSize
    }
}

extension FileSystemInfo: FileSystemNode {
    var filesCount: Int { get } {
        var filesCount = 0
        if let file = self as? .file {
            filesCount += 1
        } else if let directory = self as? .directory {
            filesCount += directory.contents.map { it.filesCount }.sum()
        }
        return filesCount
    }
}

extension FileSystemInfo: FileSystemNode {
    var treeDepth: Int { get } {
        var treeDepth = 0
        if let file = self as? .file {
            treeDepth = 0
        } else if let directory = self as? .directory {
            treeDepth = max(directory.contents.map { it.treeDepth }.max() ?? 0, 1) + 1
        }
        return treeDepth
    }
}

extension FileSystemInfo: FileSystemNode {
    func calculateInfo() -> . {
        return . {
            totalSize: self.totalSize,
            filesCount: self.filesCount,
            treeDepth: self.treeDepth,
        }
    }
}

extension FileSystemInfo {
    func calculateInfo(from: FileSystemNode) -> . {
        var result = from.calculateInfo()
        if let directory = from as? .directory {
            result.totalSize += directory.contents.map { it.calculateInfo(it).totalSize }.sum()
            result.filesCount += directory.contents.map { it.calculateInfo(it).filesCount }.sum()
            result.treeDepth = max(directory.contents.map { it.calculateInfo(it).treeDepth }.max() ?? 0, 1) + 1
        }
        return result
    }
}

extension FileSystemInfo {
    func calculateInfo(from: FileSystemNode, to: FileSystemNode) -> . {
        var result = from.calculateInfo(to)
        if let directory = from as? .directory {
            result.totalSize += directory.contents.map { it.calculateInfo(it, to).totalSize }.sum()
            result.filesCount += directory.contents.map { it.calculateInfo(it, to).filesCount }.sum()
            result.treeDepth = max(directory.contents.map { it.calculateInfo(it, to).treeDepth }.max() ?? 0, 1) + 1
        }
        return result
    }
}

    var totalSize: Int { get } {
        var totalSize = 0
        if let file = self as? .file {
            totalSize += file.size
        } else if let directory = self as? .directory {
            totalSize += directory.contents.map { it.totalSize }.sum()
        }
        return totalSize
    }
}

extension FileSystemInfo: FileSystemNode {
    var filesCount: Int { get } {
        var filesCount = 0
        if let file = self as? .file {
            filesCount += 1
        } else if let directory = self as? .directory {
            filesCount += directory.contents.map { it.filesCount }.sum()
        }
        return filesCount
    }
}

extension FileSystemInfo: FileSystemNode {
    var treeDepth: Int { get } {
        var treeDepth = 0
        if let file = self as? .file {
            treeDepth = 0
        } else if let directory = self as? .directory {
            treeDepth = max(directory.contents.map { it.treeDepth }.max() ?? 0, 1) + 1
        }
        return treeDepth
    }
}

extension FileSystemInfo: FileSystemNode {
    func calculateInfo() -> . {
        return . {
            totalSize: self.totalSize,
            filesCount: self.filesCount,
            treeDepth: self.treeDepth,
        }
    }
}

extension FileSystemInfo {
    func calculateInfo(from: FileSystemNode) -> . {
        var result = from.calculateInfo()
        if let directory = from as? .directory {
            result.totalSize += directory.contents.map { it.calculateInfo(it).totalSize }.sum()
            result.filesCount += directory.contents.map { it.calculateInfo(it).filesCount }.sum()
            result.treeDepth = max(directory.contents.map { it.calculateInfo(it).treeDepth }.max() ?? 0, 1) + 1
        }
        return result
    }
}

extension FileSystemInfo {
    func calculateInfo(from: FileSystemNode, to: FileSystemNode) -> . {
        var result = from.calculateInfo(to)
        if let directory = from as? .directory {
            result.totalSize += directory.contents.map { it.calculateInfo(it, to).totalSize }.sum()
            result.filesCount += directory.contents.map { it.calculateInfo(it, to).filesCount }.sum()
            result.treeDepth = max(directory.contents.map { it.calculateInfo(it, to).treeDepth }.max() ?? 0, 1) + 1
        }
        return result
    }
}

extension FileSystemInfo {
    func calculateInfo(from: FileSystemNode, to: FileSystemNode, <|fim_middle|>
# %%
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Abstract file system manager and metadata calculation.
Used to calculate total size of all files in file system, files count and file system tree depth.

### Response:

indirect enum FileSystemNode {
    case file(name: String, size: Int)
    case directory(name: String, contents: [FileSystemNode])
}

protocol FileSystemInfo {
    var totalSize: Int { get }
    var filesCount: Int { get }
    var treeDepth: Int { get }
}

extension FileSystemNode: FileSystemInfo {
    var totalSize: Int { get } {
        return match self {
            case file(size: size) in
                size
            case directory(contents: contents) in
                contents.map { it.totalSize }.reduce(0) { + }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var filesCount: Int { get } {
        return match self {
            case file() in
                1
            case directory(contents: contents) in
                contents.map { it.filesCount }.reduce(0) { + }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var treeDepth: Int { get } {
        return match self {
            case file() in
                0
            case directory(contents: contents) in
                1 + contents.map { it.treeDepth }.reduce(0) { + }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var totalSize: Int { get } {
        return match self {
            case file(size: size) in
                size
            case directory(contents: contents) in
                contents.map { it.totalSize }.reduce(0) { + }
        }
    }
}

    var totalSize: Int { get } {
        return match self {
            case file(size: size) in
                size
            case directory(contents: contents) in
                contents.map { it.totalSize }.reduce(0) { + }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var filesCount: Int { get } {
        return match self {
            case file() in
                1
            case directory(contents: contents) in
                contents.map { it.filesCount }.reduce(0) { + }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var treeDepth: Int { get } {
        return match self {
            case file() in
                0
            case directory(contents: contents) in
                1 + contents.map { it.treeDepth }.reduce(0) { + }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var totalSize: Int { get } {
        return match self {
            case file(size: size) in
                size
            case directory(contents: contents) in
                contents.map { it.totalSize }.reduce(0) { + }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var filesCount: Int { get } {
        return match self {
            case file() in
                1
            case directory(contents: contents) in
                contents.map { it.filesCount }.reduce(0) { + }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var treeDepth: Int { get } {
        return match self {
            case file() in
                0
            case directory(contents: contents) in
                1 + contents.map { it.treeDepth }.reduce(0) { + }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var totalSize: Int { get } {
        return match self {
            case file(size: size) in
                size
            case directory(contents: contents) in
                contents.map { it.totalSize }.reduce(0) { + }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var filesCount: Int { get } {
        return match self {
            case file() in
                1
            case directory(contents: contents) in
                contents.map { it.filesCount }.reduce(0) { + }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var treeDepth: Int { get } {
        return match self {
            case file() in
                0
            case directory(contents: contents) in
                1 + contents.map { it.treeDepth }.reduce(0) { + }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var totalSize: Int { get } {
        return match self {
            case file(size: size) in
                size
            case directory(contents: contents) in
                contents.map { it.totalSize }.reduce(0) { + }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var filesCount: Int { get } {
        return match self {
            case file() in
                1
            case directory(contents: contents) in
                contents.map { it.filesCount }.reduce(0) { + }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var treeDepth: Int { get } {
        return match self {
            case file() in
                0
            case directory(contents: contents) in
    <|fim_middle|>%%
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Abstract file system manager and metadata calculation.
Used to calculate total size of all files in file system, files count and file system tree depth.
### Response:

indirect enum FileSystemNode {
    case file(name: String, size: Int)
    case directory(name: String, contents: [FileSystemNode])
}

protocol FileSystemInfo {
    var totalSize: Int { get }
    var filesCount: Int { get }
    var treeDepth: Int { get }
}

extension FileSystemNode: FileSystemInfo {
    var name: String { get }
}

extension FileSystemNode {
    var size: Int {
        case let file(size) = size
        case let directory(contents) = contents.sumBy { it.size }
    }
}

extension FileSystemNode {
    var contents: [FileSystemNode] {
        case let directory(contents) = contents
    }
}

extension FileSystemNode {
    var depth: Int {
        case let file() = 0
        case let directory(contents) = 1 + contents.maxBy { it.depth }?.depth ?? 0
    }
}

extension FileSystemNode {
    var isFile: Bool {
        case let file() = true
        case let directory() = false
    }
}

extension FileSystemNode {
    var isDirectory: Bool {
        case let directory() = true
        case let file() = false
    }
}

extension FileSystemNode {
    var isLeaf: Bool {
        case let file() = false
        case let directory(contents) = contents.any { it.isLeaf }
    }
}

extension FileSystemNode {
    var isRoot: Bool {
        case let file() = false
        case let directory() = false
    }
}

extension FileSystemNode {
    var isLeafOrRoot: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isLeafOrRoot }
    }
}

extension FileSystemNode {
    var isRootOrLeaf: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeaf }
    }
}

extension FileSystemNode {
    var isLeafOrRootOrLeaf: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isLeafOrRootOrLeaf }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRoot: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRoot }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeaf: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeaf }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeafOrRoot: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeafOrRoot }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeafOrRootOrLeaf: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeafOrRootOrLeaf }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeafOrRootOrLeafOrRoot: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeafOrRootOrLeafOrRoot }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeaf: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeaf }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeafOrRoot: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeafOrRoot }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeaf: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeaf }
    }
}

    var name: String { get }
}

extension FileSystemNode {
    var size: Int {
        case let file(size) = size
        case let directory(contents) = contents.sumBy { it.size }
    }
}

extension FileSystemNode {
    var contents: [FileSystemNode] {
        case let directory(contents) = contents
    }
}

extension FileSystemNode {
    var depth: Int {
        case let file() = 0
        case let directory(contents) = 1 + contents.maxBy { it.depth }?.depth ?? 0
    }
}

extension FileSystemNode {
    var isFile: Bool {
        case let file() = true
        case let directory() = false
    }
}

extension FileSystemNode {
    var isDirectory: Bool {
        case let directory() = true
        case let file() = false
    }
}

extension FileSystemNode {
    var isLeaf: Bool {
        case let file() = false
        case let directory(contents) = contents.any { it.isLeaf }
    }
}

extension FileSystemNode {
    var isRoot: Bool {
        case let file() = false
        case let directory() = false
    }
}

extension FileSystemNode {
    var isLeafOrRoot: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isLeafOrRoot }
    }
}

extension FileSystemNode {
    var isRootOrLeaf: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeaf }
    }
}

extension FileSystemNode {
    var isLeafOrRootOrLeaf: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isLeafOrRootOrLeaf }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRoot: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRoot }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeaf: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeaf }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeafOrRoot: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeafOrRoot }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeafOrRootOrLeaf: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeafOrRootOrLeaf }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeafOrRootOrLeafOrRoot: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeafOrRootOrLeafOrRoot }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeaf: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeaf }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeafOrRoot: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeafOrRoot }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeaf: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeaf }
    }
}

extension FileSystemNode {
    var isRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeafOrRootOrLeafOrRoot: Bool {
        case let file() = true
        case let directory(contents) = contents.any { it.isRootOrLeafOrRootOrLeaf

indirect enum FileSystemNode {
    case file(name: String, size: Int)
    case directory(name: String, contents: [FileSystemNode])
}

protocol FileSystemInfo {
    var totalSize: Int { get }
    var filesCount: Int { get }
    var treeDepth: Int { get }
}

extension FileSystemInfo: FileSystemNode {
    var totalSize: Int { get } = 0
    var filesCount: Int { get } = 0
    var treeDepth: Int { get } = 0
}

extension FileSystemNode: FileSystemInfo {
    var name: String {
        switch self {
            case let file(name:) in name
            case let directory(name:) in name
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var name: String {
        switch self {
            case let file(name:) in name
            case let directory(name:) in name
        }
    }
}

extension FileSystemNode: FileSystemInfo {
    var contents: [FileSystemNode] {
        switch self {
            case let directory(contents:) in contents
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var contents: [FileSystemNode] {
        switch self {
            case let directory(contents:) in contents
        }
    }
}

extension FileSystemNode: FileSystemInfo {
    var depth: Int {
        switch self {
            case let file(<|fim_suffix|>
            case let directory(contents:) in contents.map { it.depth }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var depth: Int {
        switch self {
            case let file(depth:) in depth
            case let directory(contents:) in contents.map { it.depth }
        }
    }
}

extension FileSystemNode: FileSystemInfo {
    var isDirectory: Bool {
        switch self {
            case let file() in false
            case let directory() in true
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var isDirectory: Bool {
        switch self {
            case let file() in false
            case let directory() in true
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var isFile: Bool {
        switch self {
            case let file() in true
            case let directory() in false
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var isTreeEmpty: Bool {
        switch self {
            case let file() in false
            case let directory(contents:) in contents.map { it.isTreeEmpty }
        }
    }
}

    var size: Int {
        switch self {
            case let file(size:) in size
            case let directory(contents:) in contents.sumBy { it.size }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var totalSize: Int { get } = 0
    var filesCount: Int { get } = 0
    var treeDepth: Int { get } = 0
}

extension FileSystemNode: FileSystemInfo {
    var name: String {
        switch self {
            case let file(name:) in name
            case let directory(name:) in name
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var name: String {
        switch self {
            case let file(name:) in name
            case let directory(name:) in name
        }
    }
}

extension FileSystemNode: FileSystemInfo {
    var contents: [FileSystemNode] {
        switch self {
            case let directory(contents:) in contents
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var contents: [FileSystemNode] {
        switch self {
            case let directory(contents:) in contents
        }
    }
}

extension FileSystemNode: FileSystemInfo {
    var depth: Int {
        switch self {
            case let file(<|fim_suffix|>
            case let directory(contents:) in contents.map { it.depth }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var depth: Int {
        switch self {
            case let file(depth:) in depth
            case let directory(contents:) in contents.map { it.depth }
        }
    }
}

extension FileSystemNode: FileSystemInfo {
    var isDirectory: Bool {
        switch self {
            case let file() in false
            case let directory() in true
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var isDirectory: Bool {
        switch self {
            case let file() in false
            case let directory() in true
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var isFile: Bool {
        switch self {
            case let file() in true
            case let directory() in false
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var isFile: Bool {
        switch self {
            case let file() in true
            case let directory() in false
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var isTreeEmpty: Bool {
        switch self {
            case let file() in false
            case let directory(contents:) in contents.map { it.isTreeEmpty }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var isTreeEmpty: Bool {
        switch self {
            case let file() in false
            case let directory(contents:) in contents.map { it.isTreeEmpty }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var isTreeEmpty: Bool {
        switch self {
            case let file() in false
            case let directory(contents:) in contents.map { it.isTreeEmpty }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var isTreeEmpty: Bool {
        switch self {
            case let file() in false
            case let directory(contents:) in contents.map { it.isTreeEmpty }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var isTreeEmpty: Bool {
        switch self {
            case let file() in false
            case let directory(contents:) in contents.map { it.isTreeEmpty }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var isTreeEmpty: Bool {
        switch self {
            case let file() in false
            case let directory(contents:) in contents.map { it.isTreeEmpty }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var isTreeEmpty: Bool {
        switch self {
            case let file() in false
            case let directory(contents:) in contents.map { it.isTreeEmpty }
        }
    }
}

ex<|fim_middle|>depth:) in depth<|file_separator|>

indirect enum FileSystemNode {
    case file(name: String, size: Int)
    case directory(name: String, contents: [FileSystemNode])
}

protocol FileSystemInfo {
    var totalSize: Int { get }
    var filesCount: Int { get }
    var treeDepth: Int { get }
}

extension FileSystemNode: FileSystemInfo {
    var size: Int { get {
        if let file = self {
            return file.size
        } else if let directory = self {
            return directory.contents.map { it.size }.sum()
        } else {
            fatalError("Unknown node type")
        }
    } }
}

extension FileSystemInfo {
    var totalSize: Int { get {
        return self.contents.map { it.size }.sum()
    } }

    var filesCount: Int { get {
        return self.contents.filter { it is.file }.count()
    } }

    var treeDepth: Int { get {
        return self.contents.map { it.treeDepth }.max() ?? 0
    } }
}

extension FileSystemNode {
    var name: String { get {
        if let file = self {
            return file.name
        } else if let directory = self {
            return directory.name
        } else {
            fatalError("Unknown node type")
        }
    } }
}

extension FileSystemNode {
    var contents: [FileSystemNode] { get {
        if let file = self {
            return []
        } else if let directory = self {
            return directory.contents
        } else {
            fatalError("Unknown node type")
        }
    } }
}

extension FileSystemNode {
    var treeDepth: Int { get {
        return 1 + self.contents.map { it.treeDepth }.max() ?? 0
    } }
}

extension FileSystemInfo {
    var root: FileSystemNode { get {
        return self
    } }
}

extension FileSystemNode {
    var isFile: Bool { get {
        return self is.file
    } }
}

extension FileSystemNode {
    var isDirectory: Bool { get {
        return self is.directory
    } }
}

extension FileSystemNode {
    var isRoot: Bool { get {
        return self is.root
    } }
}

    var size: Int { get {
        if let file = self {
            return file.size
        } else if let directory = self {
            return directory.contents.map { it.size }.sum()
        } else {
            fatalError("Unknown node type")
        }
    } }
}

extension FileSystemInfo {
    var totalSize: Int { get {
        return self.contents.map { it.size }.sum()
    } }

    var filesCount: Int { get {
        return self.contents.filter { it is.file }.count()
    } }

    var treeDepth: Int { get {
        return self.contents.map { it.treeDepth }.max() ?? 0
    } }
}

extension FileSystemNode {
    var name: String { get {
        if let file = self {
            return file.name
        } else if let directory = self {
            return directory.name
        } else {
            fatalError("Unknown node type")
        }
    } }
}

extension FileSystemNode {
    var contents: [FileSystemNode] { get {
        if let file = self {
            return []
        } else if let directory = self {
            return directory.contents
        } else {
            fatalError("Unknown node type")
        }
    } }
}

extension FileSystemNode {
    var treeDepth: Int { get {
        return 1 + self.contents.map { it.treeDepth }.max() ?? 0
    } }
}

extension FileSystemInfo {
    var root: FileSystemNode { get {
        return self
    } }
}

extension FileSystemNode {
    var isFile: Bool { get {
        return self is.file
    } }
}

extension FileSystemNode {
    var isDirectory: Bool { get {
        return self is.directory
    } }
}

extension FileSystemNode {
    var isRoot: Bool { get {
        return self is.root
    } }
}

extension FileSystemInfo {
    var root: FileSystemNode { get {
        return self
    } }
}

extension FileSystemNode {
    var isFile: Bool { get {
        return self is.file
    } }
}

extension FileSystemNode {
    var isDirectory: Bool { get {
        return self is.directory
    } }
}

extension FileSystemNode {
    var isRoot: Bool { get {
        return self is.root
    } }
}

extension FileSystemInfo {
    var root: FileSystemNode { get {
        return self
    } }
}

extension FileSystemNode {
    var isFile: Bool { get {
        return self is.file
    } }
}

extension FileSystemNode {
    var isDirectory: Bool { get {
        return self is.directory
    } }
}

extension FileSystemNode {
    var isRoot: Bool { get {
        return self is.root
    } }
}

extension FileSystemInfo {
    var root: FileSystemNode { get {
        return self
    } }
}

extension FileSystemNode {
    var isFile: Bool { get {
        return self is.file
    } }
}

extension FileSystemNode {
    var isDirectory: Bool { get {
        return self is.directory
    } }
}

extension FileSystemNode {
    var isRoot: Bool { get {
        return self is.root
    } }
}

extension FileSystemInfo {
    var root: FileSystemNode { get {
        return self
    } }
}

extension FileSystemNode {
    var isFile: Bool { get {
        return self is.file
    } }
}

extension FileSystemNode {
    var isDirectory: Bool { get {
        return self is.directory
    } }
}

extension FileSystemNode {
    var isRoot: Bool { get {
        return self is.root
    } }
}

extension FileSystemInfo {
    var root: FileSystemNode { get {
        return self
    } }
}

extension FileSystemNode {
    var isFile: Bool { get {
        return self is.file
    } }
}

extension FileSystemNode {
    var isDirectory: Bool { get {
        return self is.directory
    } }
}

extension FileSystemNode {
    var isRoot: Bool { get {
        return self is.root
    } }
}

extension FileSystemInfo {
    var root: FileSystemNode { get {
        return self
    } }
}

indirect enum FileSystemNode {
    case file(name: String, size: Int)
    case directory(name: String, contents: [FileSystemNode])
}

protocol FileSystemInfo {
    var totalSize: Int { get }
    var filesCount: Int { get }
    var treeDepth: Int { get }
}

extension FileSystemNode: FileSystemInfo {
    var size: Int {
        switch self {
            case let file(size:) in size
            case let directory(contents:) in contents.sumBy { it.size }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var totalSize: Int { get } = 0
    var filesCount: Int { get } = 0
    var treeDepth: Int { get } = 0
}

extension FileSystemNode {
    var name: String {
        switch self {
            case let file(name:) in name
            case let directory(name:) in name
        }
    }
}

extension FileSystemInfo {
    func totalSize() -> Int {
        totalSize += self.size
        return totalSize
    }
}

extension FileSystemNode {
    func treeDepth() -> Int {
        let depth = 1
        switch self {
            case let directory(contents:) in contents.maxBy { it.treeDepth() + 1 }.treeDepth()
            case let file(<|fim_suffix|>
        return depth
    }
}

extension FileSystemInfo {
    func filesCount() -> Int {
        filesCount += 1
        return filesCount
    }
}

extension FileSystemNode {
    func size() -> Int {
        switch self {
            case let file(size:) in size
            case let directory(contents:) in contents.sumBy { it.size }
        }
    }
}

extension FileSystemNode {
    func name() -> String {
        switch self {
            case let file(name:) in name
            case let directory(name:) in name
        }
    }
}

extension FileSystemInfo {
    func treeDepth() -> Int {
        let depth = 1
        switch self {
            case let directory(contents:) in contents.maxBy { it.treeDepth() + 1 }.treeDepth()
            case let file(size:) in 0
        }
        return depth
    }
}

    var size: Int {
        switch self {
            case let file(size:) in size
            case let directory(contents:) in contents.sumBy { it.size }
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var totalSize: Int { get } = 0
    var filesCount: Int { get } = 0
    var treeDepth: Int { get } = 0
}

extension FileSystemNode {
    var name: String {
        switch self {
            case let file(name:) in name
            case let directory(name:) in name
        }
    }
}

extension FileSystemInfo {
    func totalSize() -> Int {
        totalSize += self.size
        return totalSize
    }
}

extension FileSystemNode {
    func treeDepth() -> Int {
        let depth = 1
        switch self {
            case let directory(contents:) in contents.maxBy { it.treeDepth() + 1 }.treeDepth()
            case let file(<|fim_suffix|>
        return depth
    }
}

extension FileSystemInfo {
    func filesCount() -> Int {
        filesCount += 1
        return filesCount
    }
}

extension FileSystemNode {
    func size() -> Int {
        switch self {
            case let file(size:) in size
            case let directory(contents:) in contents.sumBy { it.size }
        }
    }
}

extension FileSystemNode {
    func name() -> String {
        switch self {
            case let file(name:) in name
            case let directory(name:) in name
        }
    }
}

extension FileSystemInfo {
    func treeDepth() -> Int {
        let depth = 1
        switch self {
            case let directory(contents:) in contents.maxBy { it.treeDepth() + 1 }.treeDepth()
            case let file(size:) in 0
        }
        return depth
    }
}

extension FileSystemNode {
    func size() -> Int {
        switch self {
            case let file(size:) in size
            case let directory(contents:) in contents.sumBy { it.size }
        }
    }
}

extension FileSystemInfo {
    func filesCount() -> Int {
        filesCount += 1
        return filesCount
    }
}

extension FileSystemNode {
    func name() -> String {
        switch self {
            case let file(name:) in name
            case let directory(name:) in name
        }
    }
}

extension FileSystemInfo {
    func treeDepth() -> Int {
        let depth = 1
        switch self {
            case let directory(contents:) in contents.maxBy { it.treeDepth() + 1 }.treeDepth()
            case let file(size:) in 0
        }
        return depth
    }
}

extension FileSystemNode {
    func size() -> Int {
        switch self {
            case let file(size:) in size
            case let directory(contents:) in contents.sumBy { it.size }
        }
    }
}

extension FileSystemInfo {
    func filesCount() -> Int {
        filesCount += 1
        return filesCount
    }
}

extension FileSystemNode {
    func name() -> String {
        switch self {
            case let file(name:) in name
            case let directory(name:) in name
        }
    }
}

extension FileSystemInfo {
    func treeDepth() -> Int {
        let depth = 1
        switch self {
            case let directory(contents:) in contents.maxBy { it.treeDepth() + 1 }.treeDepth()
            case let file(size:) in 0
        }
        return depth
    }
}

extension FileSystemNode {
    func size() -> Int {
        switch self {
            case let file(size:) in size
            case let directory(contents:) in contents.sumBy { it.size }
        }
    }
}

extension FileSystemInfo {
    func filesCount() -> Int {
        filesCount += 1
        return filesCount
    }
}

extension FileSystemNode {
    func name() -> String {
        switch self {
            case let file(name:) in name
            case let directory(name:) in name
        }
    }
}

extension FileSystemInfo {
    func treeDepth() -> Int {
        let depth = 1
        switch self {
            case let directory(contents

indirect enum FileSystemNode {
    case file(name: String, size: Int)
    case directory(name: String, contents: [FileSystemNode])
}

protocol FileSystemInfo {
    var totalSize: Int { get }
    var filesCount: Int { get }
    var treeDepth: Int { get }
}

extension FileSystemNode: FileSystemInfo {
    var name: String { get }
}

extension FileSystemNode {
    var size: Int { get }
}

extension FileSystemNode {
    var contents: [FileSystemNode] { get }
}

extension FileSystemNode {
    var depth: Int { get } where FileSystemNode {
        if let contents = self.contents {
            return 1 + contents.map { it.depth }.max!
        } else {
            return 1
        }
    }
}

extension FileSystemInfo {
    var totalSize: Int {
        var totalSize = 0
        for node in self {
            totalSize += node.size
        }
        return totalSize
    }
}

extension FileSystemInfo {
    var filesCount: Int {
        var filesCount = 0
        for node in self {
            if let contents = node.contents {
                filesCount += contents.count { it is! FileSystemNode.directory }
            } else {
                filesCount += 1
            }
        }
        return filesCount
    }
}

extension FileSystemInfo {
    var treeDepth: Int {
        var treeDepth = 0
        for node in self {
            treeDepth = max(treeDepth, node.depth)
        }
        return treeDepth
    }
}

extension FileSystemNode {
    var name: String {
        return self.name
    }

    var size: Int {
        return self.size
    }

    var contents: [FileSystemNode] {
        return self.contents
    }

    var depth: Int {
        return self.depth
    }
}

extension FileSystemNode.file {
    var name: String {
        return self.name
    }

    var size: Int {
        return self.size
    }

    var contents: [FileSystemNode] {
        return []
    }

    var depth: Int {
        return 1
    }
}

extension FileSystemNode.directory {
    var name: String {
        return self.name
    }

    var size: Int {
        return self.contents.map { it.size }.sum
    }

    var contents: [FileSystemNode] {
        return self.contents
    }

    var depth: Int {
        return 1 + self.contents.map { it.depth }.max!
    }
}

extension FileSystemInfo {
    var totalSize: Int {
        return self.totalSize
    }

    var filesCount: Int {
        return self.filesCount
    }

    var treeDepth: Int {
        return self.treeDepth
    }
}

    var name: String { get }
}

extension FileSystemNode {
    var size: Int { get }
}

extension FileSystemNode {
    var contents: [FileSystemNode] { get }
}

extension FileSystemNode {
    var depth: Int { get } where FileSystemNode {
        if let contents = self.contents {
            return 1 + contents.map { it.depth }.max!
        } else {
            return 1
        }
    }
}

extension FileSystemInfo {
    var totalSize: Int {
        var totalSize = 0
        for node in self {
            totalSize += node.size
        }
        return totalSize
    }
}

extension FileSystemInfo {
    var filesCount: Int {
        var filesCount = 0
        for node in self {
            if let contents = node.contents {
                filesCount += contents.count { it is! FileSystemNode.directory }
            } else {
                filesCount += 1
            }
        }
        return filesCount
    }
}

extension FileSystemInfo {
    var treeDepth: Int {
        var treeDepth = 0
        for node in self {
            treeDepth = max(treeDepth, node.depth)
        }
        return treeDepth
    }
}

extension FileSystemNode {
    var name: String {
        return self.name
    }

    var size: Int {
        return self.size
    }

    var contents: [FileSystemNode] {
        return self.contents
    }

    var depth: Int {
        return self.depth
    }
}

extension FileSystemNode.file {
    var name: String {
        return self.name
    }

    var size: Int {
        return self.size
    }

    var contents: [FileSystemNode] {
        return []
    }

    var depth: Int {
        return 1
    }
}

extension FileSystemNode.directory {
    var name: String {
        return self.name
    }

    var size: Int {
        return self.contents.map { it.size }.sum
    }

    var contents: [FileSystemNode] {
        return self.contents
    }

    var depth: Int {
        return 1 + self.contents.map { it.depth }.max!
    }
}

extension FileSystemNode.file {
    var name: String {
        return self.name
    }

    var size: Int {
        return self.size
    }

    var contents: [FileSystemNode] {
        return []
    }

    var depth: Int {
        return 1
    }
}

extension FileSystemNode.directory {
    var name: String {
        return self.name
    }

    var size: Int {
        return self.contents.map { it.size }.sum
    }

    var contents: [FileSystemNode] {
        return self.contents
    }

    var depth: Int {
        return 1 + self.contents.map { it.depth }.max!
    }
}

extension FileSystemInfo {
    var totalSize: Int {
        return self.totalSize
    }

    var filesCount: Int {
        return self.filesCount
    }

    var treeDepth: Int {
        return self.treeDepth
    }
}

extension FileSystemInfo {
    var totalSize: Int {
        return self.totalSize
    }

    var filesCount: Int {
        return self.filesCount
    }

    var treeDepth: Int {
        return self.treeDepth
    }
}

extension FileSystemInfo {
    var totalSize: Int {
        return self.totalSize
    }

    var filesCount: Int {
        return self.filesCount
    }

    var treeDepth: Int {
        return self.treeDepth
    }
}

extension FileSystemInfo {
    var totalSize: Int {
        return self.totalSize
    }

    var filesCount: Int {
        return self.filesCount
    }

    var treeDepth: Int {
        return self.treeDepth
    }
}

extension FileSystemInfo {
    var totalSize: Int {
        return self.totalSize
    }

    var filesCount: Int {
        return self.filesCount
    }

    var treeDepth: Int {
        return self.treeDepth
    }
}

extension FileSystemInfo {
    var totalSize: Int

indirect enum FileSystemNode {
    case file(name: String, size: Int)
    case directory(name: String, contents: [FileSystemNode])
}

protocol FileSystemInfo {
    var totalSize: Int { get }
    var filesCount: Int { get }
    var treeDepth: Int { get }
}

extension FileSystemNode: FileSystemInfo {
    var totalSize: Int { get } {
        var size = 0
        switch self {
            case let file(size: Int) {
                size = size
            }
            case let directory(contents: [FileSystemNode]) {
                size = contents.map { it.totalSize }.reduce(0) { a, b in a + b }
            }
        }
        return size
    }

    var filesCount: Int { get } {
        var count = 0
        switch self {
            case let file() {
                count = 1
            }
            case let directory(contents: [FileSystemNode]) {
                count = contents.map { it.filesCount }.reduce(0) { a, b in a + b }
            }
        }
        return count
    }

    var treeDepth: Int { get } {
        var depth = 0
        switch self {
            case let file() {
                depth = 0
            }
            case let directory(contents: [FileSystemNode]) {
                depth = contents.map { it.treeDepth }.reduce(0) { a, b in max(a, b) } + 1
            }
        }
        return depth
    }
}

extension FileSystemInfo: FileSystemNode {
    var totalSize: Int { get } {
        return self.totalSize
    }

    var filesCount: Int { get } {
        return self.filesCount
    }

    var treeDepth: Int { get } {
        return self.treeDepth
    }
}

extension FileSystemNode {
    var name: String {
        return self.name
    }
}

extension String {
    var name: String {
        return self
    }
}

extension Int {
    var name: String {
        return self.toString()
    }
}

extension FileSystemNode {
    var contents: [FileSystemNode] {
        return self.contents
    }
}

extension FileSystemNode {
    var parent: FileSystemNode? {
        return self.parent
    }
}

extension FileSystemNode {
    var children: [FileSystemNode] {
        return self.children
    }
}

    var totalSize: Int { get } {
        var size = 0
        switch self {
            case let file(size: Int) {
                size = size
            }
            case let directory(contents: [FileSystemNode]) {
                size = contents.map { it.totalSize }.reduce(0) { a, b in a + b }
            }
        }
        return size
    }

    var filesCount: Int { get } {
        var count = 0
        switch self {
            case let file() {
                count = 1
            }
            case let directory(contents: [FileSystemNode]) {
                count = contents.map { it.filesCount }.reduce(0) { a, b in a + b }
            }
        }
        return count
    }

    var treeDepth: Int { get } {
        var depth = 0
        switch self {
            case let file() {
                depth = 0
            }
            case let directory(contents: [FileSystemNode]) {
                depth = contents.map { it.treeDepth }.reduce(0) { a, b in max(a, b) } + 1
            }
        }
        return depth
    }
}

extension FileSystemInfo: FileSystemNode {
    var totalSize: Int { get } {
        return self.totalSize
    }

    var filesCount: Int { get } {
        return self.filesCount
    }

    var treeDepth: Int { get } {
        return self.treeDepth
    }
}

extension FileSystemNode {
    var name: String {
        return self.name
    }
}

extension String {
    var name: String {
        return self
    }
}

extension Int {
    var name: String {
        return self.toString()
    }
}

extension FileSystemNode {
    var contents: [FileSystemNode] {
        return self.contents
    }
}

extension FileSystemNode {
    var parent: FileSystemNode? {
        return self.parent
    }
}

extension FileSystemNode {
    var parent: FileSystemNode? {
        return self.parent
    }
}

extension FileSystemNode {
    var children: [FileSystemNode] {
        return self.children
    }
}

extension FileSystemNode {
    var children: [FileSystemNode] {
        return self.children
    }
}

extension FileSystemNode {
    var parent: FileSystemNode? {
        return self.parent
    }
}

extension FileSystemNode {
    var parent: FileSystemNode? {
        return self.parent
    }
}

extension FileSystemNode {
    var children: [FileSystemNode] {
        return self.children
    }
}

extension FileSystemNode {
    var children: [FileSystemNode] {
        return self.children
    }
}

extension FileSystemNode {
    var parent: FileSystemNode? {
        return self.parent
    }
}

extension FileSystemNode {
    var parent: FileSystemNode? {
        return self.parent
    }
}

extension FileSystemNode {
    var children: [FileSystemNode] {
        return self.children
    }
}

extension FileSystemNode {
    var children: [FileSystemNode] {
        return self.children
    }
}

extension FileSystemNode {
    var parent: FileSystemNode? {
        return self.parent
    }
}

extension FileSystemNode {
    var parent: FileSystemNode? {
        return self.parent
    }
}

extension FileSystemNode {
    var children: [FileSystemNode] {
        return self.children
    }
}

extension FileSystemNode {
    var children: [FileSystemNode] {
        return self.children
    }
}

extension FileSystemNode {
    var parent: FileSystemNode? {
        return self.parent
    }
}

extension FileSystemNode {
    var parent: FileSystemNode? {
        return self.parent
    }
}

extension FileSystemNode {
    var children: [FileSystemNode] {
        return self.children
    }
}

extension FileSystemNode {
    var children: [FileSystemNode] {
        return self.children
    }
}

extension FileSystemNode {
    var parent: FileSystemNode? {
        return self.parent
    }
}

extension FileSystemNode {
    var parent: FileSystemNode? {
        return self.parent
    }
}

extension FileSystemNode {
    var children: [FileSystemNode] {

indirect enum FileSystemNode {
    case file(name: String, size: Int)
    case directory(name: String, contents: [FileSystemNode])
}

protocol FileSystemInfo {
    var totalSize: Int { get }
    var filesCount: Int { get }
    var treeDepth: Int { get }
}

extension FileSystemNode: FileSystemInfo {
    var size: Int {
        switch self {
            case let file(size:) in
                return size
            case let directory(contents:) in
                return sum(contents.map { .size })
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var totalSize: Int {
        return sum(contents.map { .totalSize })
    }

    var filesCount: Int {
        return sum(contents.map { .filesCount })
    }

    var treeDepth: Int {
        return max(contents.map { .treeDepth })
    }
}

extension FileSystemInfo: String {
    var treeDepth: Int {
        return max(contents.map { .treeDepth })
    }
}

extension String: FileSystemInfo {
    var treeDepth: Int {
        return max(contents.map { .treeDepth })
    }
}

extension FileSystemNode: String {
    var treeDepth: Int {
        return max(contents.map { .treeDepth })
    }
}

extension FileSystemNode: String {
    var size: Int {
        return sum(contents.map { .size })
    }
}

extension String: FileSystemNode {
    var size: Int {
        return sum(contents.map { .size })
    }
}

extension FileSystemNode: String {
    var filesCount: Int {
        return sum(contents.map { .filesCount })
    }
}

extension String: FileSystemNode {
    var filesCount: Int {
        return sum(contents.map { .filesCount })
    }
}

extension FileSystemNode: String {
    var totalSize: Int {
        return sum(contents.map { .totalSize })
    }
}

extension String: FileSystemNode {
    var totalSize: Int {
        return sum(contents.map { .totalSize })
    }
}

extension String: FileSystemNode {
    var name: String {
        return self
    }
}

extension FileSystemNode: String {
    var name: String {
        return self
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension String: FileSystemNode {
    var contents: [FileSystemNode] {
        return []
    }
}

    var size: Int {
        switch self {
            case let file(size:) in
                return size
            case let directory(contents:) in
                return sum(contents.map { .size })
        }
    }
}

extension FileSystemInfo: FileSystemNode {
    var totalSize: Int {
        return sum(contents.map { .totalSize })
    }

    var filesCount: Int {
        return sum(contents.map { .filesCount })
    }

    var treeDepth: Int {
        return max(contents.map { .treeDepth })
    }
}

extension FileSystemInfo: String {
    var treeDepth: Int {
        return max(contents.map { .treeDepth })
    }
}

extension String: FileSystemInfo {
    var treeDepth: Int {
        return max(contents.map { .treeDepth })
    }
}

extension FileSystemNode: String {
    var treeDepth: Int {
        return max(contents.map { .treeDepth })
    }
}

extension FileSystemNode: String {
    var size: Int {
        return sum(contents.map { .size })
    }
}

extension String: FileSystemNode {
    var size: Int {
        return sum(contents.map { .size })
    }
}

extension FileSystemNode: String {
    var filesCount: Int {
        return sum(contents.map { .filesCount })
    }
}

extension String: FileSystemNode {
    var filesCount: Int {
        return sum(contents.map { .filesCount })
    }
}

extension FileSystemNode: String {
    var totalSize: Int {
        return sum(contents.map { .totalSize })
    }
}

extension String: FileSystemNode {
    var totalSize: Int {
        return sum(contents.map { .totalSize })
    }
}

extension String: FileSystemNode {
    var name: String {
        return self
    }
}

extension FileSystemNode: String {
    var name: String {
        return self
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension String: FileSystemNode {
    var contents: [FileSystemNode] {
        return []
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension String: FileSystemNode {
    var contents: [FileSystemNode] {
        return []
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension String: FileSystemNode {
    var contents: [FileSystemNode] {
        return []
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension String: FileSystemNode {
    var contents: [FileSystemNode] {
        return []
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension String: FileSystemNode {
    var contents: [FileSystemNode] {
        return []
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension String: FileSystemNode {
    var contents: [FileSystemNode] {
        return []
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension String: FileSystemNode {
    var contents: [FileSystemNode] {
        return []
    }
}

extension FileSystemNode: String {
    var contents: [FileSystemNode] {
        return []
    }
}

extension FileSystem

protocol StackProtocol {
    associatedtype Element
    init()
    func push(_ element: Element)
    func pop() -> Element?
}

class Stack<Element>: StackProtocol where Element:Equatable {
    var elements: [Element] = []
    var size: Int = 0
    var capacity: Int = 0
    var top: Element? = nil
    var isFull: Bool = false
    var isEmpty: Bool = false

    init(capacity: Int = 10) {
        self.capacity = capacity
        self.size = 0
    }

    func push(_ element: Element) {
        if !isFull {
            self.elements.append(element)
            self.size += 1
            self.top = element
            if self.size == self.capacity {
                self.isFull = true
            }
        }
    }

    func pop() -> Element? {
        if !isEmpty {
            let element = self.elements.last!
            self.elements.removeLast()
            self.size -= 1
            self.top = nil
            if self.size == 0 {
                self.isEmpty = true
            }
            return element
        }
        return nil
    }
}

Element>: StackProtocol where Element:Equatable {
    var elements: [Element] = []
    var size: Int = 0
    var capacity: Int = 0
    var top: Element? = nil
    var isFull: Bool = false
    var isEmpty: Bool = false

    init(capacity: Int = 10) {
        self.capacity = capacity
        self.size = 0
    }

    func push(_ element: Element) {
        if !isFull {
            self.elements.append(element)
            self.size += 1
            self.top = element
            if self.size == self.capacity {
                self.isFull = true
            }
        }
    }

    func pop() -> Element? {
        if !isEmpty {
            let element = self.elements.last!
            self.elements.removeLast()
            self.size -= 1
            self.top = nil
            if self.size == 0 {
                self.isEmpty = true
            }
            return element
        }
        return nil
    }
}

let stack = Stack<Int>(capacity: 5)
stack.push(1)
stack.push(2)
stack.push(3)
stack.push(4)
stack.push(5)
stack.push(6)
print(stack.pop())
print(stack.pop())
print(stack.pop())
print(stack.pop())
print(stack.pop())
print(stack.pop())
print(stack.pop())

protocol StackProtocol {
    associatedtype Element
    init()
    func push(_ element: Element)
    func pop() -> Element?
}

class Stack<Element>: StackProtocol where Element:Equatable {
    var elements: [Element] = []
    
    init() {}
    
    func push(_ element: Element) {
        elements.append(element)
    }
    
    func pop() -> Element? {
        if let lastElement = elements.last {
            elements.removeLast()
            return lastElement
        }
        return nil
    }
}

Element>: StackProtocol where Element:Equatable {
    var elements: [Element] = []
    
    init() {}
    
    func push(_ element: Element) {
        elements.append(element)
    }
    
    func pop() -> Element? {
        if let lastElement = elements.last {
            elements.removeLast()
            return lastElement
        }
        return nil
    }
}

let stack = Stack<Int>()
stack.push(1)
stack.push(2)
stack.push(3)
stack.push(4)

print(stack.pop()) // 4
print(stack.pop()) // 3
print(stack.pop()) // 2
print(stack.pop()) // 1
print(stack.pop()) // nil
print(stack.pop()) // nil

protocol StackProtocol {
    associatedtype Element
    init()
    func push(_ element: Element)
    func pop() -> Element?
}

class Stack<Element>: StackProtocol where Element: Any {
    var elements: [Element] = []
    var count: Int = 0

    init() {
        self.elements = []
        self.count = 0
    }

    func push(_ element: Element) {
        self.elements.append(element)
        self.count += 1
    }

    func pop() -> Element? {
        if self.count == 0 {
            return nil
        }
        self.count -= 1
        return self.elements.pop()
    }
}

Element>: StackProtocol where Element: Any {
    var elements: [Element] = []
    var count: Int = 0

    init() {
        self.elements = []
        self.count = 0
    }

    func push(_ element: Element) {
        self.elements.append(element)
        self.count += 1
    }

    func pop() -> Element? {
        if self.count == 0 {
            return nil
        }
        self.count -= 1
        return self.elements.pop()
    }
}

let stack = Stack<Int>()
stack.push(1)
stack.push(2)
stack.push(3)
print(stack.pop()) // 3
print(stack.pop()) // 2
print(stack.pop()) // 1
print(stack.pop()) // nil

protocol StackProtocol {
    associatedtype Element
    init()
    func push(_ element: Element)
    func pop() -> Element?
}

class Stack<Element>: StackProtocol where Element:Equatable, Element:NSCopying {
    var elements = [Element]()
    var size = 0
    var top: Element?
        get {
            return elements.last
        }
    var isEmpty: Bool
        get {
            return size == 0
        }

    func push(_ element: Element) {
        elements.append(element)
        size += 1
    }

    func pop() -> Element? {
        if isEmpty {
            return nil
        }
        let element = elements.last!
        elements.removeLast()
        size -= 1
        return element
    }
}

Element>: StackProtocol where Element:Equatable, Element:NSCopying {
    var elements = [Element]()
    var size = 0
    var top: Element?
        get {
            return elements.last
        }
    var isEmpty: Bool
        get {
            return size == 0
        }

    func push(_ element: Element) {
        elements.append(element)
        size += 1
    }

    func pop() -> Element? {
        if isEmpty {
            return nil
        }
        let element = elements.last!
        elements.removeLast()
        size -= 1
        return element
    }
}

let stack = Stack<Int>()
stack.push(1)
stack.push(2)
stack.push(3)
print(stack.pop()) // 3
print(stack.pop()) // 2
print(stack.pop()) // 1
print(stack.pop()) // nil

protocol StackProtocol {
    associatedtype Element
    init()
    func push(_ element: Element)
    func pop() -> Element?
}

class Stack<Element>: StackProtocol where Element: Any {
    var elements: [Element] = []
    var size: Int = 0

    init() {
        self.elements = []
        self.size = 0
    }

    func push(_ element: Element) {
        self.elements.append(element)
        self.size += 1
    }

    func pop() -> Element? {
        if self.size == 0 {
            return nil
        } else {
            self.size -= 1
            return self.elements.pop()
        }
    }
}

Element>: StackProtocol where Element: Any {
    var elements: [Element] = []
    var size: Int = 0

    init() {
        self.elements = []
        self.size = 0
    }

    func push(_ element: Element) {
        self.elements.append(element)
        self.size += 1
    }

    func pop() -> Element? {
        if self.size == 0 {
            return nil
        } else {
            self.size -= 1
            return self.elements.pop()
        }
    }
}

let stack = Stack<Int>()
stack.push(1)
stack.push(2)
stack.push(3)
print(stack.pop()) // 3
print(stack.pop()) // 2
print(stack.pop()) // 1
print(stack.pop()) // nil

protocol StackProtocol {
    associatedtype Element
    init()
    func push(_ element: Element)
    func pop() -> Element?
}

class Stack<Element>: StackProtocol where Element: Equatable {
    var elements: [Element] = []
    
    init() {
        self.elements = []
    }
    
    func push(_ element: Element) {
        self.elements.append(element)
    }
    
    func pop() -> Element? {
        let result = self.elements.last
        self.elements.removeLast()
        return result
    }
}

extension Stack<Element> {
    func peek() -> Element? {
        return self.elements.last
    }
}

extension Stack<Element> {
    func isEmpty() -> Bool {
        return self.elements.isEmpty
    }
}

extension Stack<Element> {
    func size() -> Int {
        return self.elements.count
    }
}

extension Stack<Element> {
    func toString() -> String {
        return self.elements.map({ $0.toString() }).join(", ")
    }
}

extension Stack<Element> {
    static func fromString(string: String) -> Stack<Element> {
        let stack = Stack<Element>()
        let elements = string.split(", ")
        for element in elements {
            stack.push(element as Element)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromArray(array: [Element]) -> Stack<Element> {
        let stack = Stack<Element>()
        for element in array {
            stack.push(element)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromSet(set: Set<Element>) -> Stack<Element> {
        let stack = Stack<Element>()
        for element in set {
            stack.push(element)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromDictionary(dictionary: Dictionary<String, Element>) -> Stack<Element> {
        let stack = Stack<Element>()
        for key, value in dictionary {
            stack.push(value)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromIterable(iterable: Iterable<Element>) -> Stack<Element> {
        let stack = Stack<Element>()
        for element in iterable {
            stack.push(element)
        }
        return stack
    }
}

Element>: StackProtocol where Element: Equatable {
    var elements: [Element] = []
    
    init() {
        self.elements = []
    }
    
    func push(_ element: Element) {
        self.elements.append(element)
    }
    
    func pop() -> Element? {
        let result = self.elements.last
        self.elements.removeLast()
        return result
    }
}

extension Stack<Element> {
    func peek() -> Element? {
        return self.elements.last
    }
}

extension Stack<Element> {
    func isEmpty() -> Bool {
        return self.elements.isEmpty
    }
}

extension Stack<Element> {
    func size() -> Int {
        return self.elements.count
    }
}

extension Stack<Element> {
    func toString() -> String {
        return self.elements.map({ $0.toString() }).join(", ")
    }
}

extension Stack<Element> {
    static func fromString(string: String) -> Stack<Element> {
        let stack = Stack<Element>()
        let elements = string.split(", ")
        for element in elements {
            stack.push(element as Element)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromArray(array: [Element]) -> Stack<Element> {
        let stack = Stack<Element>()
        for element in array {
            stack.push(element)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromSet(set: Set<Element>) -> Stack<Element> {
        let stack = Stack<Element>()
        for element in set {
            stack.push(element)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromDictionary(dictionary: Dictionary<String, Element>) -> Stack<Element> {
        let stack = Stack<Element>()
        for key, value in dictionary {
            stack.push(value)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromIterable(iterable: Iterable<Element>) -> Stack<Element> {
        let stack = Stack<Element>()
        for element in iterable {
            stack.push(element)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromRange(range: R<|file_separator|>

protocol StackProtocol {
    associatedtype Element
    init()
    func push(_ element: Element)
    func pop() -> Element?
}

class Stack<Element>: StackProtocol where Element: Equatable {
    var elements: [Element] = []
    init() {}
    func push(_ element: Element) {
        elements.append(element)
    }
    func pop() -> Element? {
        if elements.isEmpty {
            return nil
        }
        let last = elements.last!
        elements.removeLast()
        return last
    }
}

Element>: StackProtocol where Element: Equatable {
    var elements: [Element] = []
    init() {}
    func push(_ element: Element) {
        elements.append(element)
    }
    func pop() -> Element? {
        if elements.isEmpty {
            return nil
        }
        let last = elements.last!
        elements.removeLast()
        return last
    }
}

let stack = Stack<Int>()
stack.push(1)
stack.push(2)
stack.push(3)
print(stack.pop()) // 3
print(stack.pop()) // 2
print(stack.pop()) // 1
print(stack.pop()) // nil

protocol StackProtocol {
    associatedtype Element
    init()
    func push(_ element: Element)
    func pop() -> Element?
}

class Stack<Element>: StackProtocol where Element:Equatable {
    var elements: [Element] = []
    
    init() {}
    
    func push(_ element: Element) {
        elements.append(element)
    }
    
    func pop() -> Element? {
        let element = elements.last
        elements.removeLast()
        return element
    }
}

Element>: StackProtocol where Element:Equatable {
    var elements: [Element] = []
    
    init() {}
    
    func push(_ element: Element) {
        elements.append(element)
    }
    
    func pop() -> Element? {
        let element = elements.last
        elements.removeLast()
        return element
    }
}

let stack = Stack<Int>()
stack.push(1)
stack.push(2)
stack.push(3)
stack.push(4)
print(stack.pop())
print(stack.pop())
print(stack.pop())
print(stack.pop())
print(stack.pop())

protocol StackProtocol {
    associatedtype Element
    init()
    func push(_ element: Element)
    func pop() -> Element?
}

class Stack<Element>: StackProtocol where Element:Equatable {
    let _stack = [Element]()
    var _top: Int = 0

    init() {
        _stack = [Element]()
        _top = 0
    }

    func push(_ element: Element) {
        _stack[_top] = element
        _top += 1
    }

    func pop() -> Element? {
        if _top == 0 {
            return nil
        }

        let element = _stack[_top - 1]
        _top -= 1
        return element
    }
}

Element>: StackProtocol where Element:Equatable {
    let _stack = [Element]()
    var _top: Int = 0

    init() {
        _stack = [Element]()
        _top = 0
    }

    func push(_ element: Element) {
        _stack[_top] = element
        _top += 1
    }

    func pop() -> Element? {
        if _top == 0 {
            return nil
        }

        let element = _stack[_top - 1]
        _top -= 1
        return element
    }
}

let stack = Stack<Int>()
stack.push(1)
stack.push(2)
stack.push(3)
stack.push(4)
stack.push(5)

let topElement = stack.pop()
print("Top element: \(topElement)")

let topElement2 = stack.pop()
print("Top element: \(topElement2)")

let topElement3 = stack.pop()
print("Top element: \(topElement3)")

protocol StackProtocol {
    associatedtype Element
    init()
    func push(_ element: Element)
    func pop() -> Element?
}

class Stack<Element>: StackProtocol where Element:Equatable {
    var elements: [Element] = []
    
    init() {
        self.elements = []
    }
    
    func push(_ element: Element) {
        self.elements.append(element)
    }
    
    func pop() -> Element? {
        if let lastElement = self.elements.last {
            let element = lastElement
            self.elements.removeLast()
            return element
        } else {
            return nil
        }
    }
}

extension Stack<Element> {
    func peek() -> Element? {
        if let lastElement = self.elements.last {
            return lastElement
        } else {
            return nil
        }
    }
}

extension Stack<Element> {
    func isEmpty() -> Bool {
        return self.elements.isEmpty
    }
}

extension Stack<Element> {
    func size() -> Int {
        return self.elements.count
    }
}

extension Stack<Element> {
    func clear() {
        self.elements = []
    }
}

extension Stack<Element> {
    func toArray() -> [Element] {
        return self.elements
    }
}

extension Stack<Element> {
    static func fromArray<Element>(elements: [Element]) -> Stack<Element> {
        let stack = Stack<Element>()
        for element in elements {
            stack.push(element)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromString(string: String) -> Stack<String> {
        let stack = Stack<String>()
        for character in string {
            stack.push(character.toString())
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromInt(int: Int) -> Stack<Int> {
        let stack = Stack<Int>()
        for i in 0..<int {
            stack.push(i)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromBool(bool: Bool) -> Stack<Bool> {
        let stack = Stack<Bool>()
        for i in 0..<bool {
            stack.push(i)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromDouble(double: Double) -> Stack<Double> {
        let stack = Stack<Double>()
        for i in 0..<double {
            stack.push(i)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromFloat(float: Float) -> Stack<Float> {
        let stack = Stack<Float>()
        for i in 0..<float {
            stack.push(i)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromChar(char: Char) -> Stack<Char> {
        let stack = Stack<Char>()
        for i in 0..<char {
            stack.push(i)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromSet<Element>(set: Set<Element>) -> Stack<Element> {
        let stack = Stack<Element>()
        for element in set {
            stack.push(element)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromDictionary<Key, Value>(dictionary: Dictionary<Key, Value>) -> Stack<Value> {
        let stack = Stack<Value>()
        for value in dictionary.values {
            stack.push(value)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromArray<Element>(array: Array<Element>) -> Stack<Element> {
        let stack = Stack<Element>()
        for element in array {
            stack.push(element)
        }
        return stack
    }
}

Element>: StackProtocol where Element:Equatable {
    var elements: [Element] = []
    
    init() {
        self.elements = []
    }
    
    func push(_ element: Element) {
        self.elements.append(element)
    }
    
    func pop() -> Element? {
        if let lastElement = self.elements.last {
            let element = lastElement
            self.elements.removeLast()
            return element
        } else {
            return nil
        }
    }
}

extension Stack<Element> {
    func peek() -> Element? {
        if let lastElement = self.elements.last {
            return lastElement
        } else {
            return nil
        }
    }
}

extension Stack<Element> {
    func isEmpty() -> Bool {
        return self.elements.isEmpty
    }
}

extension Stack<Element> {
    func size() -> Int {
        return self.elements.count
    }
}

extension Stack<Element> {
    func clear() {
        self.elements = []
    }
}

extension Stack<Element> {
    func toArray() -> [Element] {
        return self.elements
    }
}

extension Stack<Element> {
    static func fromArray<Element>(elements: [Element]) -> Stack<Element> {
        let stack = Stack<Element>()
        for element in elements {
            stack.push(element)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromString(string: String) -> Stack<String> {
        let stack = Stack<String>()
        for character in string {
            stack.push(character.toString())
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromInt(int: Int) -> Stack<Int> {
        let stack = Stack<Int>()
        for i in 0..<int {
            stack.push(i)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromBool(bool: Bool) -> Stack<Bool> {
        let stack = Stack<Bool>()
        for i in 0..<bool {
            stack.push(i)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromDouble(double: Double) -> Stack<Double> {
        let stack = Stack<Double>()
        for i in 0..<double {
            stack.push(i)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromFloat(float: Float) -> Stack<Float> {
        let stack = Stack<Float>()
        for i in 0..<float {
            stack.push(i)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromChar(char: Char) -> Stack<Char> {
        let stack = Stack<Char>()
        for i in 0..<char {
            stack.push(i)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromSet<Element>(set: Set<Element>) -> Stack<Element> {
        let stack = Stack<Element>()
        for element in set {
            stack.push(element)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromDictionary<Key, Value>(dictionary: Dictionary<Key, Value>) -> Stack<Value> {
        let stack = Stack<Value>()
        for value in dictionary.values {
            stack.push(value)
        }
        return stack
    }
}

extension Stack<Element> {
    static func fromArray<Element>(array: Array<Element>) -> Stack<Element> {
        let stack = Stack<Element>()
        for element in array {
            stack.push(element)
        }
        return stack
    }
}

exte<|fim_middle|># %%
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
Generic stack with push and pop functions.
### Response: